diff --git a/apps/edr-freight-api/src/app.module.ts b/apps/edr-freight-api/src/app.module.ts
index e435267a1..3ca5f6cb1 100644
--- a/apps/edr-freight-api/src/app.module.ts
+++ b/apps/edr-freight-api/src/app.module.ts
@@ -277,6 +277,9 @@ export class AppModule implements OnApplicationBootstrap {
     // await this.demoUsersSeeder.run();
     // await this.freightStaffUsersSeeder.run();
     // await this.pricingDataSeeder.run();
+    // IndodeFacilitySeeder keys its warehouses on INDODE_OPEN / INDODE_CLOSED, so
+    // it will not recognise a hand-created Indode warehouse and will seed a second
+    // one alongside it. Only enable it against an Indode that has no warehouse.
     // await this.indodeFacilitySeeder.run();
     // await this.batch14TestDataSeeder.run();
     // await this.batch5TestDataSeeder.run();
diff --git a/apps/edr-freight-api/src/common/validators/is-not-backdated.validator.spec.ts b/apps/edr-freight-api/src/common/validators/is-not-backdated.validator.spec.ts
new file mode 100644
index 000000000..dd22f3c37
--- /dev/null
+++ b/apps/edr-freight-api/src/common/validators/is-not-backdated.validator.spec.ts
@@ -0,0 +1,72 @@
+import { validate } from 'class-validator';
+import { IsISO8601, IsOptional } from 'class-validator';
+
+import { CLOCK_SKEW_TOLERANCE_MS, IsNotBackdated } from './is-not-backdated.validator';
+
+class Subject {
+  @IsOptional()
+  @IsISO8601()
+  @IsNotBackdated()
+  occurredAt?: string;
+}
+
+const subjectWith = (occurredAt?: string) => {
+  const subject = new Subject();
+  subject.occurredAt = occurredAt;
+  return subject;
+};
+
+const errorsFor = async (occurredAt?: string) => validate(subjectWith(occurredAt));
+
+const backdatedErrors = (errors: Awaited<ReturnType<typeof errorsFor>>) =>
+  errors.filter((error) => Object.keys(error.constraints ?? {}).includes('IsNotBackdated'));
+
+describe('IsNotBackdated', () => {
+  it('rejects a timestamp from the past', async () => {
+    const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+
+    const errors = await errorsFor(yesterday);
+
+    expect(backdatedErrors(errors)).toHaveLength(1);
+    expect(errors[0].constraints?.IsNotBackdated).toBe(
+      'occurredAt cannot be backdated — it must be now or later',
+    );
+  });
+
+  it('accepts now', async () => {
+    const errors = await errorsFor(new Date().toISOString());
+
+    expect(errors).toHaveLength(0);
+  });
+
+  it('accepts a value stale only by transit and clock skew', async () => {
+    // What an honest caller sends: "now" as of when the request was built.
+    const almostNow = new Date(Date.now() - (CLOCK_SKEW_TOLERANCE_MS - 5_000)).toISOString();
+
+    const errors = await errorsFor(almostNow);
+
+    expect(errors).toHaveLength(0);
+  });
+
+  it('rejects a value staler than the skew allowance', async () => {
+    const tooStale = new Date(Date.now() - (CLOCK_SKEW_TOLERANCE_MS + 5_000)).toISOString();
+
+    const errors = await errorsFor(tooStale);
+
+    expect(backdatedErrors(errors)).toHaveLength(1);
+  });
+
+  it('ignores an absent value so @IsOptional decides', async () => {
+    const errors = await errorsFor(undefined);
+
+    expect(errors).toHaveLength(0);
+  });
+
+  it('leaves an unparseable value to the format validator', async () => {
+    const errors = await errorsFor('not-a-date');
+
+    // Reported as a format problem, not as a backdate.
+    expect(backdatedErrors(errors)).toHaveLength(0);
+    expect(errors[0].constraints).toHaveProperty('isIso8601');
+  });
+});
diff --git a/apps/edr-freight-api/src/common/validators/is-not-backdated.validator.ts b/apps/edr-freight-api/src/common/validators/is-not-backdated.validator.ts
new file mode 100644
index 000000000..7a767e7f8
--- /dev/null
+++ b/apps/edr-freight-api/src/common/validators/is-not-backdated.validator.ts
@@ -0,0 +1,56 @@
+import {
+  registerDecorator,
+  ValidationArguments,
+  ValidationOptions,
+  ValidatorConstraint,
+  ValidatorConstraintInterface,
+} from 'class-validator';
+
+/**
+ * A caller may not stamp an event as having happened before now.
+ *
+ * A request cannot reach the server at the instant it was built, and a caller's
+ * clock is not the server's, so a timestamp that honestly means "now" always
+ * arrives a little stale. Comparing straight against `Date.now()` would reject
+ * it. The skew allowance below is what makes an honest "now" pass — it is not a
+ * window for backdating, and it is deliberately far too small to reach any
+ * earlier event worth backdating to.
+ */
+export const CLOCK_SKEW_TOLERANCE_MS = 60_000;
+
+@ValidatorConstraint({ name: 'IsNotBackdated', async: false })
+export class IsNotBackdatedConstraint implements ValidatorConstraintInterface {
+  validate(value: unknown, args: ValidationArguments): boolean {
+    // Absence is not this validator's business; pair with @IsOptional.
+    if (value === undefined || value === null || value === '') return true;
+    const parsed = new Date(value as string | Date);
+    // An unparseable value is a format error — let @IsISO8601/@IsDateString own
+    // that message rather than reporting it as a backdate.
+    if (Number.isNaN(parsed.getTime())) return true;
+    const toleranceMs = (args.constraints?.[0] as number | undefined) ?? CLOCK_SKEW_TOLERANCE_MS;
+    return parsed.getTime() >= Date.now() - toleranceMs;
+  }
+
+  defaultMessage(args: ValidationArguments): string {
+    return `${args.property} cannot be backdated — it must be now or later`;
+  }
+}
+
+/**
+ * Rejects a timestamp earlier than now, give or take {@link CLOCK_SKEW_TOLERANCE_MS}.
+ * Pass a different tolerance only with a reason.
+ */
+export function IsNotBackdated(
+  toleranceMs: number = CLOCK_SKEW_TOLERANCE_MS,
+  validationOptions?: ValidationOptions,
+) {
+  return function (object: object, propertyName: string) {
+    registerDecorator({
+      target: object.constructor,
+      propertyName,
+      options: validationOptions,
+      constraints: [toleranceMs],
+      validator: IsNotBackdatedConstraint,
+    });
+  };
+}
diff --git a/apps/edr-freight-api/src/contracts/contract-rate-schedule.builder.spec.ts b/apps/edr-freight-api/src/contracts/contract-rate-schedule.builder.spec.ts
new file mode 100644
index 000000000..a7b007617
--- /dev/null
+++ b/apps/edr-freight-api/src/contracts/contract-rate-schedule.builder.spec.ts
@@ -0,0 +1,98 @@
+import { ContractRateScheduleBuilder } from './contract-rate-schedule.builder';
+import { Rate } from '../modules/rule-engine/entities/rate.entity';
+
+/** Minimal Rate factory for the builder unit tests. */
+function rate(partial: Partial<Rate>): Rate {
+  return {
+    trigger: 'ALWAYS',
+    appliesTo: 'CONTAINER',
+    tradeDirection: 'IMPORT',
+    rateType: 'CONTAINER_IMPORT',
+    currency: 'USD',
+    rateValue: 200,
+    rateUnit: 'PER_CONTAINER',
+    ...partial,
+  } as Rate;
+}
+
+describe('ContractRateScheduleBuilder', () => {
+  const LIVE: Rate[] = [
+    rate({
+      appliesTo: 'CONTAINER',
+      tradeDirection: 'IMPORT',
+      rateType: 'CONTAINER_IMPORT',
+      rateValue: 200,
+      rateUnit: 'PER_CONTAINER',
+      originYard: { label: 'Negad' } as never,
+      destinationYard: { label: 'Mojo Dry Port' } as never,
+      containerType: { label: '40ft GP' } as never,
+    }),
+    rate({
+      appliesTo: 'CONTAINER',
+      tradeDirection: 'EXPORT', // wrong direction — must be filtered out for import
+      rateType: 'CONTAINER_EXPORT',
+      rateValue: 819,
+      originYard: { label: 'GMP' } as never,
+      destinationYard: { label: 'SGTD' } as never,
+    }),
+    rate({
+      appliesTo: 'BULK', // wrong freight — filtered out for a container contract
+      tradeDirection: 'IMPORT',
+      rateType: 'BULK_IMPORT',
+      rateUnit: 'PER_WAGON',
+      rateValue: 100,
+    }),
+    rate({
+      appliesTo: 'FIRST_MILE',
+      trigger: 'ALWAYS',
+      tradeDirection: null,
+      rateUnit: 'PER_CONTAINER',
+      rateValue: 50,
+    }),
+    rate({
+      appliesTo: 'OTHER',
+      trigger: 'CUSTOMS_CLEARANCE',
+      tradeDirection: null,
+      rateType: 'CUSTOMS_CLEARANCE',
+      rateUnit: 'FLAT',
+      rateValue: 120,
+    }),
+  ];
+
+  const build = (dir: 'IMP' | 'EXP' | 'DOM', freight: 'CON' | 'BULK') => {
+    const service = { findLiveRatesDetailed: jest.fn().mockResolvedValue(LIVE) };
+    return new ContractRateScheduleBuilder(service as never).build(dir, freight);
+  };
+
+  it('shows only import container lanes for an import container contract', async () => {
+    const s = await build('IMP', 'CON');
+    expect(s.freightLanes).toHaveLength(1);
+    expect(s.freightLanes[0]).toMatchObject({
+      route: 'Negad → Mojo Dry Port',
+      cargo: '40ft GP',
+      currency: 'USD',
+      amount: '200',
+      unit: 'per container',
+    });
+  });
+
+  it('always lists route-agnostic services and surcharges', async () => {
+    const s = await build('IMP', 'CON');
+    expect(s.additionalServices).toHaveLength(1);
+    expect(s.additionalServices[0].route).toBe('First-mile pickup by truck');
+    expect(s.surcharges).toHaveLength(1);
+    expect(s.surcharges[0].route).toBe('Customs clearance service');
+  });
+
+  it('excludes container lanes from a bulk contract', async () => {
+    const s = await build('IMP', 'BULK');
+    expect(s.freightLanes).toHaveLength(1);
+    expect(s.freightLanes[0]).toMatchObject({ amount: '100', unit: 'per wagon' });
+  });
+
+  it('flags an empty schedule when nothing priced matches', async () => {
+    const service = { findLiveRatesDetailed: jest.fn().mockResolvedValue([]) };
+    const s = await new ContractRateScheduleBuilder(service as never).build('DOM', 'CON');
+    expect(s.isEmpty).toBe(true);
+  });
+});
diff --git a/apps/edr-freight-api/src/migrations/2300000000000-RepairGpsTrackingTables.ts b/apps/edr-freight-api/src/migrations/2300000000000-RepairGpsTrackingTables.ts
new file mode 100644
index 000000000..f4628db36
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2300000000000-RepairGpsTrackingTables.ts
@@ -0,0 +1,83 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Repair for environments missing the GPS tracking tables.
+ *
+ * AddGpsTracking2000000000000 creates freight.gps_devices / gps_positions, but
+ * some databases have it RECORDED in public.migrations without the tables ever
+ * landing. TypeORM never re-runs a recorded migration, so those environments
+ * stay broken through any number of restarts — the GT06 listener accepts tracker
+ * packets on its TCP port regardless of schema state and fails per packet with
+ * `relation "freight.gps_devices" does not exist`, dropping position fixes.
+ *
+ * This re-issues the same DDL under a new name so it is applied afresh. Every
+ * statement is IF NOT EXISTS, so it is a no-op where the tables already exist
+ * and safe on every environment.
+ *
+ * Kept byte-identical to the original DDL on purpose: this must converge on the
+ * schema the entities expect, not a variant of it.
+ */
+export class RepairGpsTrackingTables2300000000000 implements MigrationInterface {
+  name = "RepairGpsTrackingTables2300000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.gps_devices (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        imei varchar(20) NOT NULL UNIQUE,
+        name varchar,
+        vehicle_id uuid REFERENCES freight.vehicles(id),
+        status varchar(16) NOT NULL DEFAULT 'REGISTERED',
+        last_seen_at timestamptz,
+        last_lat numeric(10,6),
+        last_lng numeric(10,6),
+        last_speed numeric(6,2),
+        last_course int,
+        last_fix_at timestamptz,
+        voltage_level int,
+        gsm_level int,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_GPS_DEVICES_VEHICLE"
+      ON freight.gps_devices (vehicle_id)
+    `);
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.gps_positions (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        device_id uuid NOT NULL,
+        imei varchar(20) NOT NULL,
+        vehicle_id uuid,
+        lat numeric(10,6) NOT NULL,
+        lng numeric(10,6) NOT NULL,
+        speed numeric(6,2) NOT NULL DEFAULT 0,
+        course int NOT NULL DEFAULT 0,
+        satellites int NOT NULL DEFAULT 0,
+        positioned boolean NOT NULL DEFAULT false,
+        gps_time timestamptz NOT NULL,
+        alarm int NOT NULL DEFAULT 0,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz
+      )
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_GPS_POSITIONS_DEVICE_TIME"
+      ON freight.gps_positions (device_id, gps_time)
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS "IDX_GPS_POSITIONS_VEHICLE_TIME"
+      ON freight.gps_positions (vehicle_id, gps_time)
+    `);
+  }
+
+  public async down(): Promise<void> {
+    // No-op: dropping the tables would discard tracker history on environments
+    // where this migration was the one that created them. AddGpsTracking owns
+    // the teardown.
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2320000000000-YardFacilityFreightTypes.ts b/apps/edr-freight-api/src/migrations/2320000000000-YardFacilityFreightTypes.ts
new file mode 100644
index 000000000..d6e7ae273
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2320000000000-YardFacilityFreightTypes.ts
@@ -0,0 +1,30 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * A facility handles what its equipment can handle. Containers need a reach
+ * stacker or gantry, so only Indode, Modjo and Dire Dawa take them; bulk needs
+ * far less, so all five facilities load and unload it.
+ *
+ * Both default true — a facility handles everything unless someone says
+ * otherwise, which keeps existing rows working and makes the seeder the place
+ * where the real capability is stated.
+ */
+export class YardFacilityFreightTypes2320000000000 implements MigrationInterface {
+  name = 'YardFacilityFreightTypes2320000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.yard_facilities
+        ADD COLUMN IF NOT EXISTS handles_container boolean NOT NULL DEFAULT true,
+        ADD COLUMN IF NOT EXISTS handles_bulk      boolean NOT NULL DEFAULT true
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.yard_facilities
+        DROP COLUMN IF EXISTS handles_container,
+        DROP COLUMN IF EXISTS handles_bulk
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2360000000000-RefreshContractPricingArticles.ts b/apps/edr-freight-api/src/migrations/2360000000000-RefreshContractPricingArticles.ts
new file mode 100644
index 000000000..566d0308e
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2360000000000-RefreshContractPricingArticles.ts
@@ -0,0 +1,69 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+import { CONTRACT_TEMPLATE_DEFAULTS } from '../seed/data/contract-template-defaults';
+
+/**
+ * Refresh the `pricing` article body of the six seeded contract templates to
+ * the live-rate-schedule wording. The per-lane figures (e.g. "USD 400 per
+ * wagon") are now rendered from the LIVE rate config instead of frozen prose,
+ * so any template whose pricing article still carries a hardcoded price token
+ * is rewritten to the current seed text.
+ *
+ * The guard `body ~ '(USD|ETB) [0-9]'` identifies the auto-seeded original
+ * prose (which always quoted a currency + figure) and matches neither an
+ * already-migrated body nor a hand-edited one that adopted the schedule
+ * wording — so admin edits are preserved. Idempotent: after the rewrite the
+ * price token is gone, so a re-run is a no-op. Fresh databases seed the new
+ * text directly (CreateContractTemplates imports the same seed), making this
+ * a targeted backfill for databases seeded before the seed changed.
+ */
+const HARDCODED_PRICE_TOKEN = '(USD|ETB) [0-9]';
+
+export class RefreshContractPricingArticles2360000000000
+  implements MigrationInterface
+{
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    for (const seed of CONTRACT_TEMPLATE_DEFAULTS) {
+      const pricing = seed.articles.find((a) => a.id === 'pricing');
+      if (!pricing) continue;
+
+      // Rewrite only the article whose id = 'pricing', in place, and only when
+      // its body still quotes a hardcoded currency figure. jsonb_agg keeps the
+      // rest of the article (id/title/order) and every other article intact.
+      await queryRunner.query(
+        `
+        UPDATE freight.contract_templates AS t
+        SET articles = (
+          SELECT jsonb_agg(
+            CASE
+              WHEN elem->>'id' = 'pricing'
+                THEN jsonb_set(elem, '{body}', to_jsonb($2::text), true)
+              ELSE elem
+            END
+            ORDER BY ord
+          )
+          FROM jsonb_array_elements(t.articles) WITH ORDINALITY AS a(elem, ord)
+        ),
+        updated_at = now()
+        WHERE t.code = $1
+          AND EXISTS (
+            SELECT 1
+            FROM jsonb_array_elements(t.articles) AS x
+            WHERE x->>'id' = 'pricing'
+              AND x->>'body' ~ $3
+          );
+        `,
+        [seed.code, pricing.body, HARDCODED_PRICE_TOKEN],
+      );
+    }
+  }
+
+  /**
+   * Irreversible in practice — the original per-lane figures are not restored.
+   * A no-op down keeps the migration reversible-by-contract without
+   * resurrecting stale hardcoded prices.
+   */
+  public async down(): Promise<void> {
+    // intentionally empty
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2370000000000-AddContainerUnitReturnFlag.ts b/apps/edr-freight-api/src/migrations/2370000000000-AddContainerUnitReturnFlag.ts
new file mode 100644
index 000000000..1971f6166
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2370000000000-AddContainerUnitReturnFlag.ts
@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Per-container handling opt-in: each physical container can now be marked
+ * hazardous / reefer / with-return individually, next to its VGM. The hazardous
+ * and reefer flags already existed on the unit row; only the return leg was
+ * missing, so a booking of 20 containers with 10 returning empty can bill the
+ * WITH_RETURN surcharge on 10 instead of all 20.
+ *
+ * Backfill: existing rows keep false. The line-level counts
+ * (booking_container.return_quantity etc.) stay authoritative for bookings made
+ * before this change — the rule engine falls back to them when no unit is flagged.
+ */
+export class AddContainerUnitReturnFlag2370000000000 implements MigrationInterface {
+  name = 'AddContainerUnitReturnFlag2370000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "freight"."booking_container_units" ADD COLUMN IF NOT EXISTS "is_return" boolean NOT NULL DEFAULT false`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "freight"."booking_container_units" DROP COLUMN IF EXISTS "is_return"`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2380000000000-AddTrainDeactivatedStatus.ts b/apps/edr-freight-api/src/migrations/2380000000000-AddTrainDeactivatedStatus.ts
new file mode 100644
index 000000000..2c252f127
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2380000000000-AddTrainDeactivatedStatus.ts
@@ -0,0 +1,23 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * New built-train lifecycle status DEACTIVATED: staff park a train indefinitely
+ * (only allowed while it has no DRAFT/SCHEDULED/DISPATCHED schedule). Like
+ * UNDER_MAINTENANCE / OUT_OF_SERVICE it is staff-owned — the scheduler never
+ * overwrites it and refuses to schedule a deactivated train.
+ *
+ * Postgres cannot drop an enum value, so down() is a no-op.
+ */
+export class AddTrainDeactivatedStatus2380000000000 implements MigrationInterface {
+  name = 'AddTrainDeactivatedStatus2380000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TYPE "freight"."train_status" ADD VALUE IF NOT EXISTS 'DEACTIVATED'`,
+    );
+  }
+
+  public async down(): Promise<void> {
+    // Enum values cannot be removed in Postgres; leaving the label is harmless.
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2390000000000-SeedImportTrainNumbers.ts b/apps/edr-freight-api/src/migrations/2390000000000-SeedImportTrainNumbers.ts
new file mode 100644
index 000000000..99c764806
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2390000000000-SeedImportTrainNumbers.ts
@@ -0,0 +1,62 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Admin-managed catalog of IMPORT run numbers (even, Djibouti → Ethiopia)
+ * selectable in the Train Builder. The paired EXPORT number is derived
+ * (import − 1), so only the import side is configured. Seeded with the runs
+ * historically hardcoded in the backoffice's trainRuns constants; admins add
+ * new runs from the Dropdown Settings editor.
+ */
+export class SeedImportTrainNumbers2390000000000 implements MigrationInterface {
+  name = 'SeedImportTrainNumbers2390000000000';
+  private readonly code = 'import_train_numbers';
+  private readonly options: string[] = [
+    '8002',
+    '8102',
+    '8202',
+    '8302',
+    '8402',
+    '8502',
+    '8602',
+    '8702',
+    '8802',
+    '8902',
+    '9002',
+  ];
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    const existing = await queryRunner.query(
+      `SELECT id FROM freight.dropdown_settings WHERE code = $1 LIMIT 1;`,
+      [this.code],
+    );
+    if (existing.length > 0) return;
+
+    const inserted = await queryRunner.query(
+      `INSERT INTO freight.dropdown_settings (code, label, description, multiple, meta)
+       VALUES ($1, $2, $3, false, $4::jsonb)
+       RETURNING id;`,
+      [
+        this.code,
+        'Import train numbers',
+        'Even IMPORT run numbers (Djibouti → Ethiopia) selectable when building a train. The paired export number is derived automatically (import − 1).',
+        JSON.stringify({ searchable: true, clearable: true }),
+      ],
+    );
+    const settingId = inserted[0].id;
+
+    for (let i = 0; i < this.options.length; i++) {
+      const value = this.options[i];
+      await queryRunner.query(
+        `INSERT INTO freight.dropdown_options (setting_id, value, label, display_order)
+         VALUES ($1, $2, $3, $4);`,
+        [settingId, value, value, i],
+      );
+    }
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DELETE FROM freight.dropdown_settings WHERE code = $1;`, [
+      this.code,
+    ]);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/2390000000000-WidenYardCodeForSoftDeleteSuffix.ts b/apps/edr-freight-api/src/migrations/2390000000000-WidenYardCodeForSoftDeleteSuffix.ts
new file mode 100644
index 000000000..31263f4b2
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/2390000000000-WidenYardCodeForSoftDeleteSuffix.ts
@@ -0,0 +1,21 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Yard soft-delete now appends `@<epoch-ms>` to the unique code (SEBETA →
+ * SEBETA@1755612345678) so the name can be reused by a new yard while
+ * UQ_yards_code still spans soft-deleted rows. varchar(20) can't hold long
+ * codes plus the 14-char suffix, so widen to 40.
+ */
+export class WidenYardCodeForSoftDeleteSuffix2390000000000 implements MigrationInterface {
+  name = 'WidenYardCodeForSoftDeleteSuffix2390000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "freight"."yards" ALTER COLUMN "code" TYPE varchar(40)`,
+    );
+  }
+
+  public async down(): Promise<void> {
+    // Narrowing would fail on suffixed codes; keep 40.
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts b/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
index d3fe02d5f..cbb630794 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-pricing.service.ts
@@ -305,6 +305,10 @@ export class BookingPricingService {
               vgmPerUnitTons: vgm,
               totalVgmTons: qty * vgm,
               isReefer: ct.isReefer,
+              // Per-container opt-ins — PER_CONTAINER surcharges bill these.
+              hazardousQuantity: Number(bc.hazardousQuantity ?? 0),
+              reeferQuantity: Number(bc.reeferQuantity ?? 0),
+              returnQuantity: Number(bc.returnQuantity ?? 0),
             },
             perWagon: containersPerWagonForSize(ct.sizeFt),
             quantity: qty,
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-reference-data.service.ts b/apps/edr-freight-api/src/modules/bookings/booking-reference-data.service.ts
index a978fd22b..507ef43d8 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-reference-data.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-reference-data.service.ts
@@ -1,5 +1,4 @@
 import { Inject, Injectable } from "@nestjs/common";
-import { In, Not } from "typeorm";
 
 import { CargoType } from "../rule-engine/entities/cargo-type.entity";
 import { ContainerType } from "../rule-engine/entities/container-type.entity";
@@ -34,8 +33,6 @@ import {
   BookingReferenceYardDto,
 } from "./dto/booking-reference-data.dto";
 
-const LEGACY_YARD_CODES = ["LEGACY_ORIGIN", "LEGACY_DEST"] as const;
-
 export function buildCargoTypeTree(
   rows: CargoType[],
 ): BookingReferenceCargoTypeGroupDto[] {
@@ -134,10 +131,7 @@ export class BookingReferenceDataService {
     const [yards, containerTypes, serviceTypes, shippingLines, cargoTypes] =
       await Promise.all([
         this.yardsRepository.findAll({
-          where: {
-            isActive: true,
-            code: Not(In([...LEGACY_YARD_CODES])),
-          },
+          where: { isActive: true },
           order: { displayOrder: "ASC", code: "ASC" },
         }),
         this.containerTypesRepository.findAll({
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 690b66385..aacc68012 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
@@ -42,6 +42,7 @@ export class BookingTransitionService {
     private readonly bookingsRepository: BookingsRepository,
     private readonly ruleEngineService: RuleEngineService,
     private readonly pricingService: BookingPricingService,
+    @Inject(forwardRef(() => BookingContractService))
     private readonly contractService: BookingContractService,
     private readonly filesService: FilesService,
     private readonly fileUploadSettingsService: FileUploadSettingsService,
@@ -1049,7 +1050,25 @@ export class BookingTransitionService {
       booking.tradeDirection === "EXPORT" &&
       !isRoadService(booking.serviceType);
     if (isExportTrain) {
-      await this.bookingBatchService.pickExportSchedule(scheduledBooking);
+      // With export split ON the booking no longer has to ride ONE train whole:
+      // the largest fitting part is offered and the leftover rebooks on the next
+      // train. So the day is only unbookable when NO export train that day has
+      // any room at all — reject on the day total, not on a single-train fit.
+      // With the flag off this stays the strict whole-booking gate.
+      if (process.env.FREIGHT_EXPORT_SPLIT === "true") {
+        const fitting = await this.bookingBatchService.fittingTrainsForDay(
+          scheduledBooking,
+          eatDay(date),
+          "EXPORT",
+        );
+        if (!fitting.length) {
+          throw new ConflictException(
+            "No export train on this day has space left — pick another shipment day.",
+          );
+        }
+      } else {
+        await this.bookingBatchService.pickExportSchedule(scheduledBooking);
+      }
     }
 
     await this.bookingsRepository.update(bookingId, {
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 aeae7d10a..c93ebd9c7 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -1287,6 +1287,23 @@ export class BookingsRepository extends BaseRepository<Booking> {
       .getMany();
   }
 
+  /** Same as {@link findAllBySchedule} but for a page of schedules at once —
+   * one query instead of one per schedule (batch monitoring board). */
+  findAllBySchedules(scheduleIds: string[]): Promise<Booking[]> {
+    if (!scheduleIds.length) return Promise.resolve([]);
+    return this.repository
+      .createQueryBuilder('booking')
+      .leftJoinAndSelect('booking.company', 'company')
+      .leftJoinAndSelect('booking.bookingContainers', 'bookingContainer')
+      .leftJoinAndSelect('bookingContainer.containerType', 'containerType')
+      .leftJoinAndSelect('booking.cargoType', 'cargoType')
+      .where('booking.train_schedule_id IN (:...scheduleIds)', { scheduleIds })
+      .orderBy('booking.is_government', 'DESC')
+      .addOrderBy('booking.priority_score', 'DESC')
+      .addOrderBy('booking.created_at', 'ASC')
+      .getMany();
+  }
+
   /** Bookings currently reserved (SELECTED_FOR_BATCH) against a schedule. */
   findReservedForSchedule(scheduleId: string): Promise<Booking[]> {
     return this.repository
@@ -1342,6 +1359,10 @@ export class BookingsRepository extends BaseRepository<Booking> {
     if (!bookingIds.length) return Promise.resolve([]);
     return this.bookingRepo(manager).find({
       where: { id: In(bookingIds) },
+      // Per-relation SELECTs: the containerType/cargoType→wagonTypes M2M joins
+      // multiply rows badly in a single join (hot path for every allocation
+      // preview / assignment validation).
+      relationLoadStrategy: 'query',
       relations: {
         company: true,
         originYard: true,
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/booking-container-unit.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking-container-unit.entity.ts
index 619013280..217ffe5f8 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking-container-unit.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking-container-unit.entity.ts
@@ -32,6 +32,10 @@ export class BookingContainerUnit extends BaseEntity {
   @Column({ name: 'is_reefer', type: 'boolean', default: false })
   isReefer!: boolean;
 
+  /** This container ships back empty after unloading (equipment return). */
+  @Column({ name: 'is_return', type: 'boolean', default: false })
+  isReturn!: boolean;
+
   @Column({ name: 'sort_order', type: 'smallint', default: 0 })
   sortOrder!: number;
 
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 59dad2248..810232993 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
@@ -13,7 +13,10 @@ import { FilesService } from '../files/files.service';
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { BookingsService } from '../bookings/bookings.service';
 import { BookingLifecycleNotifierService } from '../bookings/booking-lifecycle-notifier.service';
-import { ClearanceMilestone } from './entities/clearance-milestone.entity';
+import {
+  ClearanceMilestone,
+  type RiskAssignmentRecord,
+} from './entities/clearance-milestone.entity';
 import { Booking } from '../bookings/entities/booking.entity';
 import { clearanceCodesForBooking } from '../bookings/clearance.util';
 import { ClearanceWorkflowService } from './clearance-workflow.service';
@@ -85,6 +88,8 @@ export interface BookingClearanceView {
   /** Customs risk level assigned by GL ET (import; visible to the customer). */
   riskLevel?: string | null;
   riskAssignedAt?: string | null;
+  /** Every risk decision, oldest first; the last entry is the current level. */
+  riskHistory?: RiskAssignmentRecord[];
   /** Post-arrival additional duty/tax round (import). */
   secondDuty?: ClearanceSecondDuty | null;
   importReleaseGranted?: boolean;
@@ -282,6 +287,12 @@ export class BookingClearanceService {
         riskMilestone?.status === 'COMPLETED' && riskMilestone.triggeredAt
           ? riskMilestone.triggeredAt.toISOString()
           : null,
+      // Every risk decision, oldest first. `riskLevel`/`riskAssignedAt` above are
+      // the current one; this is the trail behind it.
+      riskHistory:
+        riskMilestone?.status === 'COMPLETED'
+          ? (riskMilestone.metadata?.riskHistory ?? [])
+          : [],
       secondDuty,
       importReleaseGranted:
         bookingMilestone('IMPORT_RELEASE_GRANTED')?.status === 'COMPLETED',
diff --git a/apps/edr-freight-api/src/modules/contracts/clearance-milestone.risk.spec.ts b/apps/edr-freight-api/src/modules/contracts/clearance-milestone.risk.spec.ts
index eb77533ac..4ad6dab75 100644
--- a/apps/edr-freight-api/src/modules/contracts/clearance-milestone.risk.spec.ts
+++ b/apps/edr-freight-api/src/modules/contracts/clearance-milestone.risk.spec.ts
@@ -65,4 +65,80 @@ describe('ClearanceMilestoneService.assignRisk', () => {
     expect(saved.status).toBe('COMPLETED');
     expect(saved.metadata?.riskLevel).toBe('YELLOW');
   });
+
+  /**
+   * The level is customer-visible and stays correctable until duty is advised,
+   * so a changed level must leave a trail rather than overwrite the last one.
+   */
+  describe('risk history', () => {
+    it('records the first assignment with no previous level', async () => {
+      const { service } = makeService('COMPLETED');
+
+      const saved = await service.assignRisk('b-1', 'RED', 'user-1', 'initial rating', 'Abebe K.');
+
+      expect(saved.metadata?.riskHistory).toHaveLength(1);
+      expect(saved.metadata?.riskHistory?.[0]).toMatchObject({
+        level: 'RED',
+        assignedByUserId: 'user-1',
+        assignedBy: 'Abebe K.',
+        note: 'initial rating',
+      });
+      expect(saved.metadata?.riskHistory?.[0]).not.toHaveProperty('previousLevel');
+    });
+
+    it('keeps the earlier decision when the level is reassigned', async () => {
+      const { service } = makeService('COMPLETED');
+
+      await service.assignRisk('b-1', 'RED', 'user-1', undefined, 'Abebe K.');
+      const saved = await service.assignRisk('b-1', 'GREEN', 'user-2', 'downgraded', 'Sara M.');
+
+      expect(saved.metadata?.riskLevel).toBe('GREEN');
+      expect(saved.metadata?.riskHistory).toHaveLength(2);
+      // The original RED decision survives, with who made it.
+      expect(saved.metadata?.riskHistory?.[0]).toMatchObject({
+        level: 'RED',
+        assignedBy: 'Abebe K.',
+      });
+      expect(saved.metadata?.riskHistory?.[1]).toMatchObject({
+        level: 'GREEN',
+        previousLevel: 'RED',
+        assignedByUserId: 'user-2',
+        assignedBy: 'Sara M.',
+        note: 'downgraded',
+      });
+    });
+
+    it('keeps the whole chain across several reassignments, oldest first', async () => {
+      const { service } = makeService('COMPLETED');
+
+      await service.assignRisk('b-1', 'GREEN');
+      await service.assignRisk('b-1', 'YELLOW');
+      const saved = await service.assignRisk('b-1', 'RED');
+
+      expect(saved.metadata?.riskHistory?.map((e) => e.level)).toEqual([
+        'GREEN',
+        'YELLOW',
+        'RED',
+      ]);
+    });
+
+    it('does not record a repeat of the level already assigned', async () => {
+      const { service } = makeService('COMPLETED');
+
+      await service.assignRisk('b-1', 'GREEN');
+      const saved = await service.assignRisk('b-1', 'GREEN');
+
+      expect(saved.metadata?.riskHistory).toHaveLength(1);
+    });
+
+    it('always leaves riskLevel equal to the last history entry', async () => {
+      const { service } = makeService('COMPLETED');
+
+      await service.assignRisk('b-1', 'RED');
+      const saved = await service.assignRisk('b-1', 'YELLOW');
+
+      const history = saved.metadata?.riskHistory ?? [];
+      expect(saved.metadata?.riskLevel).toBe(history[history.length - 1]?.level);
+    });
+  });
 });
diff --git a/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts b/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts
index ed3597d57..b6d57263a 100644
--- a/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/clearance-milestone.service.ts
@@ -210,15 +210,50 @@ export class ClearanceMilestoneService {
    * Customs cannot risk-rate cargo still moving under transit: the T1 must be
    * closed (accepted by GL Ethiopia after the train arrives) first, which is the
    * catalog order T1_CLOSED → RISK_ASSIGNED.
+   *
+   * The level stays correctable until duty is advised off it, so each assignment
+   * is appended to `riskHistory` instead of silently replacing the last one — a
+   * customer-visible level that changes needs a trail of who changed it and when.
    */
   async assignRisk(
     bookingId: string,
     riskLevel: CustomsRiskLevel,
     userId?: string,
     note?: string,
+    actor?: string,
   ): Promise<ClearanceMilestone> {
     await this.assertT1Closed(bookingId);
-    return this.completeWithMetadata(bookingId, 'RISK_ASSIGNED', { riskLevel }, userId, note);
+
+    const existing = await this.repo.findOne({
+      where: { bookingId, milestoneCode: 'RISK_ASSIGNED' },
+    });
+    const previousLevel = existing?.metadata?.riskLevel;
+    const history = existing?.metadata?.riskHistory ?? [];
+
+    // A repeat of the level already assigned is not a decision — recording it
+    // would pad the trail with entries that changed nothing.
+    const entries =
+      previousLevel === riskLevel
+        ? history
+        : [
+            ...history,
+            {
+              level: riskLevel,
+              ...(previousLevel ? { previousLevel } : {}),
+              assignedAt: new Date().toISOString(),
+              assignedByUserId: userId ?? null,
+              assignedBy: actor ?? null,
+              note: note ?? null,
+            },
+          ];
+
+    return this.completeWithMetadata(
+      bookingId,
+      'RISK_ASSIGNED',
+      { riskLevel, riskHistory: entries },
+      userId,
+      note,
+    );
   }
 
   /** Guard: the booking's T1 must be closed before customs risk can be assigned. */
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 826bc33b0..fd1f530b8 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
@@ -25,6 +25,7 @@ import { validate20ftWeightPairing } from '../bookings/container-pairing.util';
 import { TrainSchedulingGlobalRules } from '../train-scheduling/entities/train-scheduling-global-rules.entity';
 import { TrainSchedulingService } from '../train-scheduling/train-scheduling.service';
 import { BookingBatchService } from '../train-scheduling/booking-batch.service';
+import { eatDay } from '../train-scheduling/batch-window.util';
 import { wagonsPerUnitForSize } from '../rule-engine/container-type.util';
 import { ContainerTypesService } from '../rule-engine/services/container-types.service';
 import { RuleEngineService } from '../rule-engine/rule-engine.service';
@@ -39,7 +40,10 @@ import { ContractsRepository } from './contracts.repository';
 import { ClearanceFeeService } from './clearance-fee.service';
 import { ClearanceMilestoneService } from './clearance-milestone.service';
 import { ClearanceWorkflowService } from './clearance-workflow.service';
-import { CreateBookingUnderContractDto } from './dto/create-booking-under-contract.dto';
+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'];
@@ -54,6 +58,18 @@ export interface CreateBookingUnderContractResult {
   warnings: string[];
 }
 
+/**
+ * Outstanding split remainder of a contract: what was booked in the first split
+ * booking's pre-split snapshot MINUS everything currently booked. Container
+ * contracts report per size; bulk reports one tonnage figure. `null` when the
+ * contract has no live split chain. Consumed by the remainder-placement engine
+ * to size the auto-created remainder booking.
+ */
+export type SplitOutstanding = {
+  bySize: Map<string, { total: number; outstanding: number }>;
+  bulk: { total: number; outstanding: number } | null;
+};
+
 /**
  * The single create path for shipment bookings under a contract.
  *
@@ -270,8 +286,8 @@ export class ContractBookingService {
       tradeDirection: contract.tradeDirection,
       freightType,
       cargoTypeId: this.resolveCargoTypeId(contract, dto),
-      isHazardous: contract.isHazardous,
-      isReefer: contract.isReefer,
+      isHazardous: this.resolveShipmentHandlingFlag(contract, dto, 'hazardousQuantity'),
+      isReefer: this.resolveShipmentHandlingFlag(contract, dto, 'reeferQuantity'),
       cargoTotalWeightVgm: this.resolveBulkTons(dto),
       firstMilePickupAddress: contract.firstMilePickupAddress ?? null,
       firstMilePickupLat: contract.firstMilePickupLat ?? null,
@@ -580,11 +596,40 @@ export class ContractBookingService {
     if (!booking || booking.contractId !== contract.id) {
       throw new NotFoundException(`Booking ${bookingId} not found on this contract`);
     }
-    if (!['CLEARANCE_READY', 'OPERATION_CHANGES_REQUESTED'].includes(booking.status)) {
+    if (
+      !['CLEARANCE_READY', 'OPERATION_CHANGES_REQUESTED', 'EXPIRED'].includes(
+        booking.status,
+      )
+    ) {
       throw new BadRequestException(
         'Clearance must be finalized before the booking can be completed.',
       );
     }
+    // An unpaid booking that expired at train dispatch keeps its finished
+    // per-booking clearance — GL rebooks it onto a new shipment day instead of
+    // forcing the customer through a new shipment request + clearance fee.
+    if (booking.status === 'EXPIRED') {
+      // Only a booking that completed once (it has a price, so its clearance
+      // finished and cargo is persisted) can be rebooked after expiry.
+      if (!(Number(booking.totalAmount) > 0)) {
+        throw new BadRequestException(
+          'Only a previously completed booking can be rebooked after it expires.',
+        );
+      }
+      // Expiry released the booking's contract-capacity hold; if the payload
+      // re-states the cargo, make sure the released share is still free.
+      if (dto.containers?.length || dto.bulkLines?.length) {
+        await this.assertWithinQuantityCap(contract, dto);
+      }
+      // Drop the departed train's link and fall into the day-only resubmit
+      // path below — same machinery as OPERATION_CHANGES_REQUESTED.
+      await this.bookingsRepository.update(booking.id, {
+        status: 'OPERATION_CHANGES_REQUESTED',
+        trainScheduleId: null,
+      } as never);
+      booking.status = 'OPERATION_CHANGES_REQUESTED';
+      booking.trainScheduleId = null;
+    }
     // Path B: only GL Ethiopia completes a customs instance — the customer
     // never enters shipment data on a customs contract.
     if (contract.customsClearingEnabled) {
@@ -966,9 +1011,11 @@ export class ContractBookingService {
    * (CANCELLED / REJECTED / EXPIRED) release their share. Null when the
    * contract has no live split booking.
    */
-  private async splitOutstanding(
-    contract: Contract,
-  ): Promise<{ bySize: Map<string, { total: number; outstanding: number }>; bulk: { total: number; outstanding: number } | null } | null> {
+  /**
+   * Public: the remainder-placement engine reads this to size the auto-created
+   * remainder booking. Returns `null` when there is no live split chain.
+   */
+  async splitOutstanding(contract: Contract): Promise<SplitOutstanding | null> {
     const first = await this.dataSource
       .getRepository(Booking)
       .createQueryBuilder('b')
@@ -1015,6 +1062,25 @@ export class ContractBookingService {
     const probe = await this.buildExportProbe(contract, route, dto, yards);
     const report = await this.bookingBatchService.exportSpaceReport(probe);
     if (report.scheduleId) return;
+
+    // With export split ON a booking no longer has to ride ONE train whole: the
+    // largest fitting part is offered and the leftover is rebooked on the next
+    // train. Rejecting on the single-train fit here would block exactly the
+    // bookings the split exists to serve — including the auto-created remainder,
+    // which by definition did not fit the train it was split off. Fall back to
+    // the day total: unbookable only when NO export train that day has room.
+    if (process.env.FREIGHT_EXPORT_SPLIT === 'true') {
+      const fitting = await this.bookingBatchService.fittingTrainsForDay(
+        probe,
+        eatDay(new Date(dto.scheduledDate)),
+        'EXPORT',
+      );
+      if (fitting.length > 0) return;
+      throw new BadRequestException(
+        'No export train on this day has space left — pick another shipment day.',
+      );
+    }
+
     throw new BadRequestException(
       report.fullMessage ?? 'Not enough train space for this day.',
     );
@@ -1417,6 +1483,53 @@ export class ContractBookingService {
     );
   }
 
+  /**
+   * Per-line handling counts. Each physical container carries its own hazardous
+   * / reefer / return switch (entered next to its VGM), so the count is however
+   * many units opted in. Forms that predate per-unit switches send line-level
+   * counts and no unit flags — those are honoured as-is.
+   */
+  private handlingCounts(line: CreateBookingContainerLineDto): {
+    hazardousQuantity: number;
+    reeferQuantity: number;
+    returnQuantity: number;
+  } {
+    const units = line.units ?? [];
+    const flagged = units.some((u) => u.isHazardous || u.isReefer || u.isReturn);
+    if (!flagged) {
+      return {
+        hazardousQuantity: Number(line.hazardousQuantity ?? 0),
+        reeferQuantity: Number(line.reeferQuantity ?? 0),
+        returnQuantity: Number(line.returnQuantity ?? 0),
+      };
+    }
+    return {
+      hazardousQuantity: units.filter((u) => u.isHazardous).length,
+      reeferQuantity: units.filter((u) => u.isReefer).length,
+      returnQuantity: units.filter((u) => u.isReturn).length,
+    };
+  }
+
+  /**
+   * Booking-level hazardous / reefer flags. The CONTRACT gates the service; the
+   * per-container opt-ins decide whether THIS shipment actually uses it. A
+   * container contract that allows hazardous but a booking where nobody ticked
+   * the switch is not a hazardous booking, and must not fire the surcharge.
+   * Bulk keeps the contract flag — it has its own bulk*Quantity fields.
+   */
+  private resolveShipmentHandlingFlag(
+    contract: Contract,
+    dto: CreateBookingUnderContractDto,
+    field: 'hazardousQuantity' | 'reeferQuantity',
+  ): boolean {
+    const gated = field === 'hazardousQuantity' ? contract.isHazardous : contract.isReefer;
+    if (!gated) return false;
+    if (contract.freightType !== 'CONTAINER') return true;
+    const lines = dto.containers ?? [];
+    if (!lines.length) return Boolean(gated);
+    return lines.some((l) => this.handlingCounts(l)[field] > 0);
+  }
+
   /**
    * Resolve the booking's equipment return from the per-line return quantities
    * (container freight). The CONTRACT gates the service — like hazardous:
@@ -1436,7 +1549,7 @@ export class ContractBookingService {
 
     const lines = dto.containers ?? [];
     for (const line of lines) {
-      const qty = Number(line.returnQuantity ?? 0);
+      const qty = this.handlingCounts(line).returnQuantity;
       if (qty === 0) continue;
       if (contract.equipmentReturn !== 'WITH_RETURN') {
         throw new BadRequestException(
@@ -1452,7 +1565,7 @@ export class ContractBookingService {
     }
 
     if (contract.equipmentReturn === 'WITH_RETURN') {
-      const anyReturn = lines.some((l) => Number(l.returnQuantity ?? 0) > 0);
+      const anyReturn = lines.some((l) => this.handlingCounts(l).returnQuantity > 0);
       return anyReturn ? 'WITH_RETURN' : 'WITHOUT_RETURN';
     }
     return legacy;
@@ -1490,9 +1603,10 @@ export class ContractBookingService {
         );
       }
 
+      const counts = this.handlingCounts(line);
       const containerType = await this.resolveContainerTypeForSize(
         line.containerSize,
-        contract.isReefer || (line.reeferQuantity ?? 0) > 0,
+        contract.isReefer || counts.reeferQuantity > 0,
       );
 
       const vgmPerUnit = line.units.length
@@ -1506,12 +1620,10 @@ export class ContractBookingService {
           containerTypeId: containerType.id,
           containerSize: line.containerSize,
           quantity: line.quantity,
-          hazardousQuantity: line.hazardousQuantity ?? 0,
-          reeferQuantity: line.reeferQuantity ?? 0,
+          hazardousQuantity: counts.hazardousQuantity,
+          reeferQuantity: counts.reeferQuantity,
           returnQuantity:
-            contract.equipmentReturn === 'WITH_RETURN'
-              ? (line.returnQuantity ?? 0)
-              : 0,
+            contract.equipmentReturn === 'WITH_RETURN' ? counts.returnQuantity : 0,
           vgmPerUnitTons: vgmPerUnit,
           totalVgmTons: totalVgm,
           wagonsRequired: Math.ceil(line.quantity * wagonsPerUnitForSize(containerType.sizeFt)),
@@ -1530,6 +1642,8 @@ export class ContractBookingService {
             vgmTons: unit.vgmTons,
             isHazardous: unit.isHazardous ?? false,
             isReefer: unit.isReefer ?? false,
+            isReturn:
+              contract.equipmentReturn === 'WITH_RETURN' && (unit.isReturn ?? false),
             sortOrder: sortOrder++,
           }),
         );
@@ -1630,12 +1744,14 @@ export class ContractBookingService {
       paymentCurrency: contract.paymentCurrency,
       serviceTypeId: contract.serviceTypeId,
       cargoTypeId: this.resolveCargoTypeId(contract, dto),
-      isHazardous: contract.isHazardous,
-      isReefer: contract.isReefer,
+      isHazardous: this.resolveShipmentHandlingFlag(contract, dto, 'hazardousQuantity'),
+      isReefer: this.resolveShipmentHandlingFlag(contract, dto, 'reeferQuantity'),
       equipmentReturn: this.resolveShipmentEquipmentReturn(contract, dto),
       isGovernment: contract.isGovernment,
       shippingLineId: null,
       contractRouteId: route?.id ?? null,
+      originYardId: route?.originYardId ?? null,
+      destinationYardId: route?.destinationYardId ?? null,
       cargoTotalWeightVgm: this.resolveBulkTons(dto),
       firstMilePickupAddress: contract.firstMilePickupAddress ?? null,
       lastMileDeliveryAddress: contract.lastMileDeliveryAddress ?? null,
@@ -1644,11 +1760,11 @@ export class ContractBookingService {
           containerTypeId: ct.id,
           containerSize: line.containerSize,
           quantity: line.quantity,
-          hazardousQuantity: line.hazardousQuantity ?? 0,
-          reeferQuantity: line.reeferQuantity ?? 0,
+          hazardousQuantity: this.handlingCounts(line).hazardousQuantity,
+          reeferQuantity: this.handlingCounts(line).reeferQuantity,
           returnQuantity:
             contract.equipmentReturn === 'WITH_RETURN'
-              ? (line.returnQuantity ?? 0)
+              ? this.handlingCounts(line).returnQuantity
               : 0,
           vgmPerUnitTons: line.units.length ? totalVgmTons / line.units.length : 0,
           totalVgmTons,
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 d3bbaf098..d752d071a 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
@@ -18,7 +18,10 @@ import { ClearanceWorkflowService } from './clearance-workflow.service';
 import { ClearanceMilestoneService } from './clearance-milestone.service';
 import { ContractNotifierService } from './contract-notifier.service';
 import { GlOperationsService } from './gl-operations.service';
-import { ClearanceMilestone } from './entities/clearance-milestone.entity';
+import {
+  ClearanceMilestone,
+  type RiskAssignmentRecord,
+} from './entities/clearance-milestone.entity';
 import { Contract } from './entities/contract.entity';
 import { ContractDocReviewStatus } from './entities/contract-document-review.entity';
 import { FilterContractDto } from './dto/filter-contract.dto';
@@ -102,6 +105,8 @@ export interface ContractClearanceView {
   /** Customs risk level assigned by GL ET (import; visible to the customer). */
   riskLevel?: string | null;
   riskAssignedAt?: string | null;
+  /** Every risk decision, oldest first; the last entry is the current level. */
+  riskHistory?: RiskAssignmentRecord[];
   /** Post-arrival additional duty/tax round (import). */
   secondDuty?: ClearanceSecondDuty | null;
   importReleaseGranted?: boolean;
@@ -365,6 +370,11 @@ export class ContractClearanceService {
         riskMilestone?.status === 'COMPLETED' && riskMilestone.triggeredAt
           ? riskMilestone.triggeredAt.toISOString()
           : null,
+      // Every risk decision, oldest first — see booking-clearance.service.
+      riskHistory:
+        riskMilestone?.status === 'COMPLETED'
+          ? (riskMilestone.metadata?.riskHistory ?? [])
+          : [],
       secondDuty,
       importReleaseGranted:
         bookingMilestone('IMPORT_RELEASE_GRANTED')?.status === 'COMPLETED',
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 b62b89e32..cb91fbee6 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -31,6 +31,7 @@ import {
   ApiTags,
 } from '@nestjs/swagger';
 
+import { actorLabel } from '../warehouses/current-actor.util';
 import { BookingStaff } from '../../common/booking-guards';
 import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 import {
@@ -968,13 +969,16 @@ export class ContractsController {
   assignRisk(
     @Param('bookingId', ParseUUIDPipe) bookingId: string,
     @Body() dto: AssignRiskDto,
-    @CurrentUser() user: AuthUserPayload,
+    @CurrentUser() user: TCurrentUser,
   ) {
     return this.milestoneService.assignRisk(
       bookingId,
       dto.riskLevel,
       resolveAuthUserId(user),
       dto.note,
+      // Risk history is read by people, so resolve the name now — the id alone
+      // would render as a UUID in the trail.
+      actorLabel(user),
     );
   }
 
diff --git a/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts b/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts
index 256b11b63..3b5a30ca0 100644
--- a/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts
+++ b/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts
@@ -50,6 +50,15 @@ export class CreateContainerUnitDto {
   @IsBoolean()
   @Transform(({ value }) => value === 'true' || value === true)
   isReefer?: boolean;
+
+  @ApiPropertyOptional({
+    default: false,
+    description: 'This container ships back empty (equipment return).',
+  })
+  @IsOptional()
+  @IsBoolean()
+  @Transform(({ value }) => value === 'true' || value === true)
+  isReturn?: boolean;
 }
 
 export class CreateBookingContainerLineDto {
diff --git a/apps/edr-freight-api/src/modules/contracts/entities/clearance-milestone.entity.ts b/apps/edr-freight-api/src/modules/contracts/entities/clearance-milestone.entity.ts
index d4676b8cd..14e3b86dd 100644
--- a/apps/edr-freight-api/src/modules/contracts/entities/clearance-milestone.entity.ts
+++ b/apps/edr-freight-api/src/modules/contracts/entities/clearance-milestone.entity.ts
@@ -12,14 +12,35 @@ export type MilestoneOwnerRegion = (typeof MILESTONE_OWNER_REGIONS)[number];
 export const CUSTOMS_RISK_LEVELS = ['GREEN', 'YELLOW', 'RED'] as const;
 export type CustomsRiskLevel = (typeof CUSTOMS_RISK_LEVELS)[number];
 
+/**
+ * One customs risk decision. Risk stays correctable until duty is advised off
+ * it, and the level is customer-visible, so every assignment is kept rather than
+ * overwritten — a disputed level needs to show what was set, by whom, and when.
+ */
+export interface RiskAssignmentRecord {
+  level: CustomsRiskLevel;
+  /** The level this replaced; absent on the first assignment. */
+  previousLevel?: CustomsRiskLevel;
+  assignedAt: string;
+  assignedByUserId?: string | null;
+  /** Display name resolved at assignment time, so the trail never shows a UUID. */
+  assignedBy?: string | null;
+  note?: string | null;
+}
+
 /**
  * Structured payload some milestones carry beyond a plain note (doc §11.3):
- * - RISK_ASSIGNED → `riskLevel`
+ * - RISK_ASSIGNED → `riskLevel` (current) + `riskHistory` (every assignment)
  * - DUTY_TAXES_ADVISED → `dutyAmount`, `dutyCurrency`, `declarationSerial`
  * Stored on the milestone so the timeline can render the value inline.
  */
 export interface MilestoneMetadata {
   riskLevel?: CustomsRiskLevel;
+  /**
+   * Append-only, oldest first. `riskLevel` is the current value and always
+   * equals the last entry's `level`.
+   */
+  riskHistory?: RiskAssignmentRecord[];
   dutyAmount?: number;
   dutyCurrency?: string;
   declarationSerial?: string;
diff --git a/apps/edr-freight-api/src/modules/contracts/phased-clearance.util.ts b/apps/edr-freight-api/src/modules/contracts/phased-clearance.util.ts
index aa1c956e0..f155a27be 100644
--- a/apps/edr-freight-api/src/modules/contracts/phased-clearance.util.ts
+++ b/apps/edr-freight-api/src/modules/contracts/phased-clearance.util.ts
@@ -256,6 +256,11 @@ export const PHASED_CUSTOMS_CONTRACT_QUEUE_STATUSES = [
   'FULLY_EXECUTED',
   'CONTRACT_ACTIVE',
   'CONTRACT_CLOSED',
+  // Terminal contracts stay on the list — the clearance hub is GL's history of
+  // everything that passed through, not just the live work queue.
+  'EXPIRED',
+  'CANCELLED',
+  'REJECTED',
 ] as const;
 
 /** Whether a customs clearance item belongs on the persistent GL Ethiopia list. */
@@ -275,12 +280,22 @@ export const PHASED_CUSTOMS_BOOKING_QUEUE_STATUSES = [
   'OPERATION_REQUEST_PENDING',
   'OPERATION_CHANGES_REQUESTED',
   'ROAD_DISPATCH_PENDING',
+  // Payment phase — the booking is selected/awaiting the customer's payment.
+  'SELECTED_FOR_BATCH',
+  'PNR_GENERATED',
+  'AWAITING_PAYMENT',
+  'PAYMENT_VERIFICATION_IN_PROGRESS',
   'IN_TRANSIT',
   'ARRIVED',
   'PAID',
   'COMPLETED',
   'CONTRACT_ACTIVE',
   'CONTRACT_CLOSED',
+  // Terminal bookings stay on the list — EXPIRED especially: GL rebooks it
+  // from here, and the hub doubles as clearance history.
+  'EXPIRED',
+  'CANCELLED',
+  'REJECTED',
 ] as const;
 
 /** Booking statuses that may appear on the GL Djibouti clearance list (includes post-clearance). */
diff --git a/apps/edr-freight-api/src/modules/rule-engine/dto/create-rate.dto.ts b/apps/edr-freight-api/src/modules/rule-engine/dto/create-rate.dto.ts
index 5507692d9..41971bbf1 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/dto/create-rate.dto.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/dto/create-rate.dto.ts
@@ -74,9 +74,14 @@ export class CreateRateDto {
   @Transform(({ value }) => Number(value))
   rateValue!: number;
 
-  @ApiProperty({ enum: RATE_UNITS, description: 'Unit basis for the rate' })
+  @ApiPropertyOptional({
+    enum: RATE_UNITS,
+    description:
+      'Unit basis for the rate. Optional for shapes with a forced unit (overweight is always PER_TON — the admin form hides the field and omits it); required otherwise.',
+  })
+  @IsOptional()
   @IsIn([...RATE_UNITS])
-  rateUnit!: string;
+  rateUnit?: string;
 }
 
 export class SubmitRateForApprovalDto {
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/rate-type.util.spec.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/rate-type.util.spec.ts
new file mode 100644
index 000000000..480b2c484
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/rate-type.util.spec.ts
@@ -0,0 +1,28 @@
+import { deriveRateType } from './rate-type.util';
+
+describe('deriveRateType — surcharge triggers', () => {
+  // Every surcharge trigger must land on its own rateType. A trigger with no
+  // mapping falls through to the base-freight branch and is silently stored as
+  // CANCELLATION_FEE, which both mislabels the booking's rate snapshot and
+  // hides the rate from contract pricing (which looks rateTypes up by name).
+  it.each([
+    ['HAZARDOUS', 'HAZARD_SURCHARGE'],
+    ['REEFER', 'REEFER_SURCHARGE'],
+    ['WITH_RETURN', 'RETURN_SURCHARGE'],
+    ['OVERWEIGHT', 'OVERWEIGHT_PER_TON'],
+    ['SHIPPING_LINE', 'DOUBLE_HANDLING'],
+    ['CONSOLIDATION', 'LASHING'],
+    ['CANCELLATION', 'CANCELLATION_FEE'],
+    ['DEMURRAGE', 'DEMURRAGE'],
+    ['PIL_EXTRA_FEE', 'PIL_EXTRA_FEE'],
+    ['CUSTOMS_CLEARANCE', 'CUSTOMS_CLEARANCE'],
+  ] as const)('maps trigger %s to %s', (trigger, expected) => {
+    expect(deriveRateType({ appliesTo: 'OTHER', trigger })).toBe(expected);
+  });
+
+  it('does not fall back to CANCELLATION_FEE for the empty-return service', () => {
+    expect(deriveRateType({ appliesTo: 'OTHER', trigger: 'WITH_RETURN' })).not.toBe(
+      'CANCELLATION_FEE',
+    );
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/rate-type.util.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/rate-type.util.ts
index 09f35c458..a5b5bfc30 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/rate-type.util.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/rate-type.util.ts
@@ -25,6 +25,12 @@ export function deriveRateType(input: {
         return 'HAZARD_SURCHARGE';
       case 'REEFER':
         return 'REEFER_SURCHARGE';
+      // Empty-container return service. Contract pricing looks this rateType up
+      // by name, so without the mapping a WITH_RETURN rate fell through to the
+      // base-freight branch and was stored as CANCELLATION_FEE — invisible to
+      // the contract, and mislabelled on the booking's snapshot.
+      case 'WITH_RETURN':
+        return 'RETURN_SURCHARGE';
       case 'OVERWEIGHT':
         return 'OVERWEIGHT_PER_TON';
       case 'SHIPPING_LINE':
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/yard-facility.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/yard-facility.entity.ts
index ba5a0d671..5712eed03 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/yard-facility.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/yard-facility.entity.ts
@@ -26,6 +26,17 @@ export class YardFacility extends BaseEntity {
   @Column({ name: 'has_warehouse', type: 'boolean', default: false })
   hasWarehouse!: boolean;
 
+  /**
+   * Containers need a reach stacker or gantry, so only the equipped facilities
+   * (Indode, Modjo, Dire Dawa) take them. Bulk needs far less and is handled
+   * everywhere.
+   */
+  @Column({ name: 'handles_container', type: 'boolean', default: true })
+  handlesContainer!: boolean;
+
+  @Column({ name: 'handles_bulk', type: 'boolean', default: true })
+  handlesBulk!: boolean;
+
   @Column({ name: 'equipment_notes', type: 'text', nullable: true })
   equipmentNotes?: string | null;
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/entities/yard.entity.ts b/apps/edr-freight-api/src/modules/rule-engine/entities/yard.entity.ts
index 808a102e5..226b1114d 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/entities/yard.entity.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/entities/yard.entity.ts
@@ -7,7 +7,8 @@ import { Column, Entity, Index } from 'typeorm';
 @Index(['country'])
 @Index(['isActive'])
 export class Yard extends BaseEntity {
-  @Column({ name: 'code', type: 'varchar', length: 20, unique: true })
+  // 40 leaves room for the `@<epoch-ms>` suffix soft-delete appends to free the code.
+  @Column({ name: 'code', type: 'varchar', length: 40, unique: true })
   code!: string;
 
   @Column({ name: 'label', type: 'varchar', length: 100 })
diff --git a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
index 03be1b3d0..d1715d9fd 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
@@ -42,6 +42,14 @@ export interface BookingContainerEvalInput {
   isReefer?: boolean;
   isOverweight?: boolean;
   overweightExcessTons?: number | null;
+  /**
+   * How many individual containers on this line opted into each handling
+   * service. PER_CONTAINER surcharges bill these counts, not the line
+   * quantity — 20 containers with 10 hazardous bill hazard on 10.
+   */
+  hazardousQuantity?: number;
+  reeferQuantity?: number;
+  returnQuantity?: number;
 }
 
 export interface BookingEvaluationInput {
@@ -270,6 +278,27 @@ export class RuleEngineService {
         (sum, r) => sum + (r.overweightExcessTons ?? 0),
         0,
       );
+      /**
+       * Containers that opted into this trigger's handling service, summed
+       * across lines. null when the trigger isn't per-container handling (or
+       * no line carries a count) so the caller falls back to the full count.
+       */
+      const optedInCount = (trigger: string | null): number | null => {
+        const field =
+          trigger === 'HAZARDOUS'
+            ? 'hazardousQuantity'
+            : trigger === 'REEFER'
+              ? 'reeferQuantity'
+              : trigger === 'WITH_RETURN'
+                ? 'returnQuantity'
+                : null;
+        if (!field) return null;
+        const total = input.containers.reduce(
+          (sum, c) => sum + Number(c[field] ?? 0),
+          0,
+        );
+        return total > 0 ? total : null;
+      };
 
       let triggerValue: number | null = null;
       let calculatedAmount: number;
@@ -285,7 +314,11 @@ export class RuleEngineService {
           calculatedAmount = triggerValue * rateValue;
           break;
         case 'PER_CONTAINER':
-          triggerValue = containerCount;
+          // Handling surcharges bill only the containers that opted in, not the
+          // whole line — 20 containers with 10 hazardous bill hazard on 10.
+          // Legacy bookings carry no per-container counts (all 0) while their
+          // booking-level flag is set, so fall back to the full count there.
+          triggerValue = optedInCount(rate.trigger) ?? containerCount;
           calculatedAmount = triggerValue * rateValue;
           break;
         case 'PER_WAGON':
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts
index edd9ac9f0..488865f38 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/rates.service.ts
@@ -68,15 +68,21 @@ export class RatesService {
   private resolveRateUnit(
     appliesTo: Rate['appliesTo'],
     trigger: Rate['trigger'],
-    requestedUnit: Rate['rateUnit'],
+    requestedUnit: Rate['rateUnit'] | undefined,
   ): Rate['rateUnit'] {
-    // Overweight is per-ton, full stop.
+    // Overweight is per-ton, full stop — the admin form hides the unit field
+    // for it and omits rateUnit from the payload entirely.
     if (trigger === 'OVERWEIGHT') return 'PER_TON';
 
-    if (!isRateUnitAllowed({ appliesTo, trigger, unit: requestedUnit })) {
-      const allowed = allowedRateUnits({ appliesTo, trigger }).join(', ');
+    const allowed = allowedRateUnits({ appliesTo, trigger });
+    if (!requestedUnit) {
       throw new BadRequestException(
-        `Rate unit "${requestedUnit}" is not valid for this rate. Allowed: ${allowed}.`,
+        `Pick a rate unit for this rate. Allowed: ${allowed.join(', ')}.`,
+      );
+    }
+    if (!isRateUnitAllowed({ appliesTo, trigger, unit: requestedUnit })) {
+      throw new BadRequestException(
+        `Rate unit "${requestedUnit}" is not valid for this rate. Allowed: ${allowed.join(', ')}.`,
       );
     }
     return requestedUnit;
@@ -272,7 +278,11 @@ export class RatesService {
       tradeDirection,
       isBulk: this.resolvesToBulk(appliesTo, intercityKind),
     });
-    const rateUnit = this.resolveRateUnit(appliesTo, trigger, dto.rateUnit as Rate['rateUnit']);
+    const rateUnit = this.resolveRateUnit(
+      appliesTo,
+      trigger,
+      dto.rateUnit as Rate['rateUnit'] | undefined,
+    );
 
     await this.assertNoDuplicatePattern({
       rateType,
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/yard-facilities.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/yard-facilities.service.ts
index f32b0129a..4b69c328f 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/yard-facilities.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/yard-facilities.service.ts
@@ -10,80 +10,91 @@ export interface YardFacilityInfo {
   hasFacility: boolean;
   /** The facility stores cargo — enables the warehouse flow (storage, demurrage). */
   hasWarehouse: boolean;
+  /** Containers need a reach stacker/gantry — not every facility has one. */
+  handlesContainer: boolean;
+  handlesBulk: boolean;
 }
 
 /**
- * Which yards can handle cargo, and how.
+ * Which yards can handle cargo, and what kind.
  *
  * A yard is a load/unload point when `yards.has_facility` is set; the matching
- * `yard_facilities` record says whether it also stores cargo. Facilities without a
- * warehouse move cargo on and off the train and nothing more — no storage, no
- * demurrage. This is the single resolver the journey and handling flows use, so
- * they can't drift on what a facility is.
+ * `yard_facilities` record says what it can actually do — whether it stores cargo
+ * (storage/demurrage), and which freight types its equipment can lift. Containers
+ * need a reach stacker or gantry, so only Indode, Modjo and Dire Dawa take them;
+ * bulk is handled at all five.
+ *
+ * This is the single resolver the journey and handling flows use, so they can't
+ * drift on what a facility is or what it can lift.
  */
 @Injectable()
 export class YardFacilitiesService {
   constructor(private readonly dataSource: DataSource) {}
 
-  /** Resolve a yard's handling capability. Null when the yard doesn't exist. */
-  async facilityForYard(yardId: string): Promise<YardFacilityInfo | null> {
-    const [row]: Array<{
-      yardId: string;
-      yardCode: string | null;
-      yardLabel: string | null;
-      hasFacility: boolean;
-      hasWarehouse: boolean | null;
-    }> = await this.dataSource.query(
-      `SELECT y.id            AS "yardId",
-              y.code          AS "yardCode",
-              y.label         AS "yardLabel",
-              y.has_facility  AS "hasFacility",
-              f.has_warehouse AS "hasWarehouse"
-         FROM freight.yards y
-         LEFT JOIN freight.yard_facilities f
-           ON f.yard_id = y.id AND f.deleted_at IS NULL AND f.is_active = true
-        WHERE y.id = $1 AND y.deleted_at IS NULL`,
-      [yardId],
-    );
-    if (!row) return null;
+  private readonly SELECT = `
+    SELECT y.id                AS "yardId",
+           y.code              AS "yardCode",
+           y.label             AS "yardLabel",
+           y.has_facility      AS "hasFacility",
+           f.has_warehouse     AS "hasWarehouse",
+           f.handles_container AS "handlesContainer",
+           f.handles_bulk      AS "handlesBulk"
+      FROM freight.yards y
+      LEFT JOIN freight.yard_facilities f
+        ON f.yard_id = y.id AND f.deleted_at IS NULL AND f.is_active = true`;
+
+  private toInfo(row: {
+    yardId: string;
+    yardCode: string | null;
+    yardLabel: string | null;
+    hasFacility: boolean;
+    hasWarehouse: boolean | null;
+    handlesContainer: boolean | null;
+    handlesBulk: boolean | null;
+  }): YardFacilityInfo {
+    // No facility record means no capability, whatever the flag says.
+    const hasFacility = Boolean(row.hasFacility);
     return {
       yardId: row.yardId,
       yardCode: row.yardCode,
       yardLabel: row.yardLabel,
-      hasFacility: Boolean(row.hasFacility),
-      // No facility record means no warehouse, whatever the flag says.
-      hasWarehouse: Boolean(row.hasFacility) && Boolean(row.hasWarehouse),
+      hasFacility,
+      hasWarehouse: hasFacility && Boolean(row.hasWarehouse),
+      handlesContainer: hasFacility && Boolean(row.handlesContainer),
+      handlesBulk: hasFacility && Boolean(row.handlesBulk),
     };
   }
 
+  /** Resolve a yard's handling capability. Null when the yard doesn't exist. */
+  async facilityForYard(yardId: string): Promise<YardFacilityInfo | null> {
+    const [row] = await this.dataSource.query(
+      `${this.SELECT} WHERE y.id = $1 AND y.deleted_at IS NULL`,
+      [yardId],
+    );
+    return row ? this.toInfo(row) : null;
+  }
+
   /** Every yard that can load/unload, for pickers and the intercity queues. */
   async listFacilityYards(): Promise<YardFacilityInfo[]> {
-    const rows: Array<{
-      yardId: string;
-      yardCode: string | null;
-      yardLabel: string | null;
-      hasFacility: boolean;
-      hasWarehouse: boolean | null;
-    }> = await this.dataSource.query(
-      `SELECT y.id            AS "yardId",
-              y.code          AS "yardCode",
-              y.label         AS "yardLabel",
-              y.has_facility  AS "hasFacility",
-              f.has_warehouse AS "hasWarehouse"
-         FROM freight.yards y
-         LEFT JOIN freight.yard_facilities f
-           ON f.yard_id = y.id AND f.deleted_at IS NULL AND f.is_active = true
-        WHERE y.deleted_at IS NULL
-          AND y.is_active = true
-          AND y.has_facility = true
+    const rows = await this.dataSource.query(
+      `${this.SELECT}
+        WHERE y.deleted_at IS NULL AND y.is_active = true AND y.has_facility = true
         ORDER BY y.display_order ASC, y.label ASC`,
     );
-    return rows.map((r) => ({
-      yardId: r.yardId,
-      yardCode: r.yardCode,
-      yardLabel: r.yardLabel,
-      hasFacility: true,
-      hasWarehouse: Boolean(r.hasWarehouse),
-    }));
+    return rows.map((r: Parameters<typeof this.toInfo>[0]) => this.toInfo(r));
+  }
+
+  /**
+   * Can this facility lift this cargo? Keeps the freight-type rule in one place
+   * so callers can't get it subtly wrong.
+   */
+  canHandleFreight(
+    facility: YardFacilityInfo | null,
+    freightType: string | null | undefined,
+  ): boolean {
+    if (!facility?.hasFacility) return false;
+    return String(freightType).toUpperCase() === 'CONTAINER'
+      ? facility.handlesContainer
+      : facility.handlesBulk;
   }
 }
diff --git a/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts b/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts
index 69eab608a..b698b456c 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/services/yards.service.ts
@@ -31,7 +31,7 @@ export class YardsService {
 
   /** Create a yard. */
   async create(dto: CreateYardDto): Promise<Yard> {
-    const code = generateCode(dto.label);
+    const code = generateCode(dto.label).slice(0, 40);
     const existing = await this.repository.findByCode(code);
     if (existing) throw new ConflictException(`Yard with label "${dto.label}" conflicts with existing code "${code}"`);
 
@@ -58,9 +58,19 @@ export class YardsService {
     return updated;
   }
 
-  /** Soft-delete a yard. */
+  /**
+   * Soft-delete a yard. The unique `code` (and the label) get a `@<epoch-ms>`
+   * suffix first — e.g. SEBETA → SEBETA@1755612345678 — so a new yard with the
+   * same name can be created later without tripping UQ_yards_code, which spans
+   * soft-deleted rows too.
+   */
   async remove(id: string): Promise<void> {
-    await this.findById(id);
+    const yard = await this.findById(id);
+    const suffix = `@${Date.now()}`;
+    await this.repository.update(id, {
+      code: `${yard.code.slice(0, 40 - suffix.length)}${suffix}`,
+      label: `${yard.label.slice(0, 100 - suffix.length)}${suffix}`,
+    });
     await this.repository.softDelete(id);
   }
 
diff --git a/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts b/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
index 8e40c0384..08b906e84 100644
--- a/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/train-schedules.repository.ts
@@ -21,6 +21,10 @@ export class TrainSchedulesRepository extends BaseRepository<TrainSchedule> {
   findByIdWithFullGraph(id: string, manager?: EntityManager): Promise<TrainSchedule | null> {
     return this.repo(manager).findOne({
       where: { id },
+      // One SELECT per relation instead of a single monster join — the nested
+      // wagon×allocation×booking×container branches multiply rows catastrophically
+      // when joined (measured ~925ms vs ~84ms on a 21-wagon schedule).
+      relationLoadStrategy: 'query',
       relations: {
         // Yards carry the route's display name; without them formatRouteLabel
         // degrades to the literal "Origin → Destination". Milestones (with
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 c19140d8a..fc97f772b 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
@@ -958,20 +958,21 @@ describe('BookingBatchService — built-train wagon capacity', () => {
   // assertion below that says "not full" proves those axes are ignored.
   const scheduleId = 'schedule-built';
 
-  const reservedBooking = (id: string) =>
+  const reservedBooking = (id: string, leg?: { origin: string; dest: string }) =>
     ({
       id,
       freightType: 'BULK',
       cargoTotalWeightVgm: 50, // 1 wagon at the 60T default bulk payload
       bookingContainers: [],
-      originYardId: 'yard-a',
-      destinationYardId: 'yard-b',
+      originYardId: leg?.origin ?? 'yard-a',
+      destinationYardId: leg?.dest ?? 'yard-b',
     }) as unknown as Booking;
 
   const buildService = (opts: {
     physicalWagons: number;
     reserved: Booking[];
     maxWagons?: number;
+    routeStops?: string[];
   }) => {
     const schedule = {
       id: scheduleId,
@@ -979,7 +980,7 @@ describe('BookingBatchService — built-train wagon capacity', () => {
       bookingWindowStatus: 'OPEN',
       originStationId: 'yard-a',
       destinationStationId: 'yard-b',
-      routeId: null,
+      routeId: opts.routeStops ? 'route-1' : null,
       scheduleBookings: [],
       trainSet: {
         locomotive: {
@@ -992,14 +993,23 @@ describe('BookingBatchService — built-train wagon capacity', () => {
       },
     };
     const wagonRepo = { count: jest.fn().mockResolvedValue(opts.physicalWagons) };
+    const milestoneRepo = {
+      find: jest
+        .fn()
+        .mockResolvedValue(
+          (opts.routeStops ?? []).map((yardId, i) => ({ yardId, sequenceNo: i + 1 })),
+        ),
+    };
     const genericRepo = {
       find: jest.fn().mockResolvedValue([]),
       update: jest.fn().mockResolvedValue(undefined),
     };
     const dataSource = {
-      getRepository: jest.fn((entity: { name?: string }) =>
-        entity?.name === 'Wagon' ? wagonRepo : genericRepo,
-      ),
+      getRepository: jest.fn((entity: { name?: string }) => {
+        if (entity?.name === 'Wagon') return wagonRepo;
+        if (entity?.name === 'RouteMilestone') return milestoneRepo;
+        return genericRepo;
+      }),
       transaction: jest.fn(),
     };
     const service = new BookingBatchService(
@@ -1040,6 +1050,22 @@ describe('BookingBatchService — built-train wagon capacity', () => {
     await expect(service.isScheduleFull(scheduleId)).resolves.toBe(false);
   });
 
+  it('is FULL when sub-leg bookings hold every physical wagon of a milestone route', async () => {
+    // Regression: 50 wagons sold Negad→Mojo on a Doraleh→…→Dire Dawa corridor
+    // left the pass-through edges reading "free" in the per-edge budget, so the
+    // full train's window cycled OPEN forever and the day pool never expired.
+    // A wagon is committed for the whole trip — leg-free edges are not capacity.
+    const { service } = buildService({
+      physicalWagons: 2,
+      routeStops: ['yard-a', 'yard-m1', 'yard-m2', 'yard-b'],
+      reserved: [
+        reservedBooking('b1', { origin: 'yard-m1', dest: 'yard-m2' }),
+        reservedBooking('b2', { origin: 'yard-m1', dest: 'yard-m2' }),
+      ],
+    });
+    await expect(service.isScheduleFull(scheduleId)).resolves.toBe(true);
+  });
+
   it('reports over-allocation when the consist is trimmed below committed bookings', async () => {
     const { service } = buildService({
       physicalWagons: 1,
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 866885074..4a836060e 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
@@ -33,7 +33,7 @@ import { TrainSchedulesRepository } from '../train-schedules/train-schedules.rep
 import { TrainScheduleBookingsRepository } from '../train-schedules/train-schedule-bookings.repository';
 import { BookingNotifierService } from './booking-notifier.service';
 import { TrainSchedulingService } from './train-scheduling.service';
-import { eatDay, groupBookingsIntoBoardWindows } from './batch-window.util';
+import { eatDay } from './batch-window.util';
 import {
   BATCH_BOARD_STATUSES,
   BatchBoardQueryDto,
@@ -71,6 +71,7 @@ import { WagonType } from '../wagon-types/entities/wagon-type.entity';
 import { Wagon } from '../wagons/entities/wagon.entity';
 import { ClearanceMilestoneService } from '../contracts/clearance-milestone.service';
 import { BookingSplitService } from './booking-split.service';
+import { RemainderPlacementService } from './remainder-placement.service';
 import { BookingWindowGateway } from './booking-window.gateway';
 import {
   MAX_TEU_SLOTS_PER_WAGON,
@@ -171,23 +172,18 @@ export interface BatchBoardBookingDetail extends BatchBoardBooking {
   consolidationPartnerRef: string | null;
 }
 
-export interface BatchWindowGroup {
-  key: string;
-  label: string;
-  /** EAT calendar day as ISO `YYYY-MM-DD` (empty for the pending-contract bucket). */
-  date: string;
-  /** Human label for the day, e.g. `Thu, 05 Jun` (empty for pending-contract). */
-  dateLabel: string;
-  start: string;
-  end: string;
-  counts: {
-    allocated: number;
-    selectedForBatch: number;
-    ready: number;
-    waiting: number;
-    expired: number;
-    pendingContract: number;
-  };
+export interface BatchBoardCounts {
+  allocated: number;
+  selectedForBatch: number;
+  ready: number;
+  waiting: number;
+  expired: number;
+  pendingContract: number;
+}
+
+/** A booking bucket on the detail board (in-window vs pending-contract). */
+export interface BatchBoardBucket {
+  counts: BatchBoardCounts;
   bookings: BatchBoardBookingDetail[];
 }
 
@@ -214,8 +210,9 @@ export interface BatchBoardScheduleDetail {
   locomotive: BatchBoardSchedule["locomotive"];
   capacity: BatchBoardSchedule["capacity"];
   counts: BatchBoardSchedule["counts"];
-  windows: BatchWindowGroup[];
-  pendingContract: BatchWindowGroup;
+  /** Bookings inside the schedule's booking window (fully-executed contracts). */
+  bookings: BatchBoardBookingDetail[];
+  pendingContract: BatchBoardBucket;
   allocationViolations: string[];
 }
 
@@ -317,9 +314,29 @@ export class BookingBatchService implements OnModuleInit {
 
     @Optional() private readonly milestoneService?: ClearanceMilestoneService,
     @Optional() private readonly splitService?: BookingSplitService,
+    @Optional()
+    @Inject(forwardRef(() => RemainderPlacementService))
+    private readonly remainderPlacement?: RemainderPlacementService,
 
   ) {}
 
+  /**
+   * Auto-place a paid booking's split remainder onto the next fitting train.
+   * Gated so it can ship dark: off unless FREIGHT_AUTO_REMAINDER=true.
+   */
+  private get autoRemainderEnabled(): boolean {
+    return process.env.FREIGHT_AUTO_REMAINDER === "true";
+  }
+
+  /**
+   * Let EXPORT bookings split (offer the largest fitting part, leftover rebooks
+   * on the next train). Separate flag from auto-remainder: export touches the
+   * FCFS money path, so partial-offer can be enabled independently.
+   */
+  private get exportSplitEnabled(): boolean {
+    return process.env.FREIGHT_EXPORT_SPLIT === "true";
+  }
+
   /** On boot, reconcile OPEN route-days and re-arm settle timers. */
   async onModuleInit(): Promise<void> {
     const groups = await this.openRouteDayGroups();
@@ -496,6 +513,34 @@ export class BookingBatchService implements OnModuleInit {
     // to the offered part before it boards (remainder returns to the contract cap).
     if (this.splitService) {
       await this.splitService.applySplit(bookingId);
+
+      // The split only happens on payment (here) — so auto-placing the remainder
+      // also only happens once the customer has accepted+paid. Re-read to see if
+      // applySplit actually reduced this booking (an open offer existed); if so,
+      // auto-create + place the remainder booking on the next fitting train.
+      // applySplit committed its own transaction before returning, so this reads
+      // the reduced lines. Best-effort: a placement failure never blocks the
+      // paid booking from boarding — the remainder falls back to manual rebook.
+      if (this.autoRemainderEnabled && this.remainderPlacement) {
+        const split = await this.dataSource
+          .getRepository(Booking)
+          .findOne({ where: { id: bookingId } });
+        // Export remainders only auto-place when export split is on — otherwise
+        // an export booking never splits in the first place.
+        const directionOn =
+          split?.tradeDirection !== "EXPORT" || this.exportSplitEnabled;
+        if (split?.isSplit && directionOn) {
+          await this.remainderPlacement
+            .placeRemainder(split)
+            .catch((err) =>
+              this.logger.error(
+                `Auto-place remainder failed for ${split.reference}: ${
+                  err instanceof Error ? err.message : String(err)
+                }`,
+              ),
+            );
+        }
+      }
     }
 
     const linked =
@@ -731,6 +776,76 @@ export class BookingBatchService implements OnModuleInit {
     );
   }
 
+  /**
+   * Trains that can carry a booking's leg on a given day, earliest departure
+   * first, each with the largest number of wagons it could still admit for the
+   * booking's wagon type. Direction-filtered: EXPORT bookings see export trains,
+   * IMPORT/DOMESTIC see non-export trains. Measures against the booking's FULL
+   * allowed wagon-type set ({@link dimsForAllowed}) so a train stocking a
+   * non-primary allowed type still counts. The remainder placer uses this to
+   * pick the next fitting train; the `free` wagon count is the best across the
+   * allowed types (a train fits under whichever allowed type gives most room).
+   */
+  async fittingTrainsForDay(
+    booking: Booking,
+    day: string,
+    direction: "IMPORT" | "EXPORT",
+  ): Promise<Array<{ scheduleId: string; departure: Date; freeWagons: number }>> {
+    const corridor = await this.trainSchedulesRepository.findAll({
+      where: [
+        { status: TrainScheduleStatusEnum.Draft },
+        { status: TrainScheduleStatusEnum.Scheduled },
+      ],
+    });
+    const candidates = corridor
+      .filter(
+        (s) =>
+          s.scheduledDepartureDate != null &&
+          eatDay(s.scheduledDepartureDate) === day &&
+          s.bookingWindowStatus !== "FULL" &&
+          (direction === "EXPORT"
+            ? s.direction === "EXPORT"
+            : s.direction !== "EXPORT"),
+      )
+      .sort(
+        (a, b) =>
+          a.scheduledDepartureDate!.getTime() -
+          b.scheduledDepartureDate!.getTime(),
+      );
+
+    const wagonDims = await this.loadWagonDims();
+    const dimsOptions = this.dimsForAllowed(booking, wagonDims);
+    const out: Array<{ scheduleId: string; departure: Date; freeWagons: number }> = [];
+
+    for (const candidate of candidates) {
+      const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
+        candidate.id,
+      );
+      const locomotive = schedule?.trainSet?.locomotive;
+      if (!schedule || !locomotive) continue;
+      const limits = await this.capacityLimits(locomotive);
+      const budget = await this.remainingBudget(schedule, limits, wagonDims);
+      const leg = budget.legOf(booking.originYardId, booking.destinationYardId);
+      if (!leg) continue; // this train's route doesn't carry the booking's leg
+      const room = budget.remainingFor(leg);
+      // Best usable wagons across the allowed types — a train fits under
+      // whichever configured wagon type gives it the most room.
+      let freeWagons = 0;
+      for (const dims of dimsOptions) {
+        const w = this.bookableWithin(room, dims).wagons;
+        if (w > freeWagons) freeWagons = w;
+      }
+      if (freeWagons > 0) {
+        out.push({
+          scheduleId: schedule.id,
+          departure: schedule.scheduledDepartureDate!,
+          freeWagons,
+        });
+      }
+    }
+    return out;
+  }
+
   /**
    * Advisory free-wagon count for an IMPORT/DOMESTIC booking on a given day,
    * summed across every train on the booking's corridor that day. Unlike the
@@ -789,6 +904,58 @@ export class BookingBatchService implements OnModuleInit {
     return { freeWagons, need, trainsForDay };
   }
 
+  /**
+   * Export split: no single train carries the whole booking, so offer the
+   * largest fitting part on the export train with the most room for its leg.
+   * Returns true when an offer was opened (the caller must NOT then reserve —
+   * the offer already opened its own pay window), false when the booking fits
+   * whole somewhere (normal FCFS path) or no meaningful partial exists.
+   *
+   * Only the offer is written here: the booking is reduced to the offered part
+   * on payment (applySplit), and the leftover is auto-placed afterwards. So an
+   * unpaid export booking stays whole and the customer may still cancel it.
+   */
+  private async tryExportPartialOffer(booking: Booking): Promise<boolean> {
+    if (!this.splitService) return false;
+    const report = await this.exportSpaceReport(booking);
+    // A train fits it whole — nothing to split, take the normal path.
+    if (report.scheduleId) return false;
+    if (!report.bestAvailable || report.bestAvailable.wagons < 1) return false;
+
+    if (!booking.scheduledDate) return false;
+    const day = eatDay(new Date(booking.scheduledDate));
+    const fitting = await this.fittingTrainsForDay(booking, day, "EXPORT");
+    if (!fitting.length) return false;
+    // Most room first — the largest single part ships now, the smallest leftover
+    // is what has to find another train.
+    const target = [...fitting].sort((a, b) => b.freeWagons - a.freeWagons)[0];
+
+    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
+      target.scheduleId,
+    );
+    const locomotive = schedule?.trainSet?.locomotive;
+    if (!schedule || !locomotive) return false;
+    const wagonDims = await this.loadWagonDims();
+    const limits = await this.capacityLimits(locomotive);
+    const budget = await this.remainingBudget(schedule, limits, wagonDims);
+    const leg = budget.legOf(booking.originYardId, booking.destinationYardId);
+    if (!leg) return false;
+
+    const offered = await this.tryPartialOffer(
+      booking,
+      schedule.id,
+      budget.remainingFor(leg),
+      report.need,
+    );
+    if (!offered) return false;
+    this.logger.log(
+      `[EXPORT SPLIT] offered partial to ${booking.reference} on schedule ` +
+        `${schedule.id} — leftover rebooks on the next train once paid.`,
+    );
+    this.notifyBoardChanged(schedule.id, "batch_fill");
+    return true;
+  }
+
   /**
    * Accept an export booking into the FCFS flow. Solo bookings reserve immediately.
    * A consolidated booking reserves as a pair only once BOTH partners are ready
@@ -800,6 +967,15 @@ export class BookingBatchService implements OnModuleInit {
   async acceptExportBooking(booking: Booking): Promise<void> {
     const partnerId = booking.consolidationPartnerId ?? null;
     if (!partnerId) {
+      // Export split: when no single train carries the whole booking, offer the
+      // largest fitting part instead of failing the accept. The customer pays
+      // that part; on payment applySplit reduces this booking to it and the
+      // leftover is auto-placed as its own booking on the next train. Pairs are
+      // excluded (handled below) — a shared wagon is never split.
+      if (this.exportSplitEnabled && this.isSplitEligible(booking, false)) {
+        const offered = await this.tryExportPartialOffer(booking);
+        if (offered) return;
+      }
       const scheduleId = await this.pickExportSchedule(booking);
       await this.reserveOnExport([booking], scheduleId);
       return;
@@ -1013,11 +1189,32 @@ export class BookingBatchService implements OnModuleInit {
     const wagonDims = await this.loadWagonDims();
     const linkRepo = this.dataSource.getRepository(TrainScheduleBooking);
 
+    // One links query + one bookings query for the whole page (was 2 per card).
+    const scheduleIds = schedules.map((s) => s.id);
+    const [allLinks, allBookings] = await Promise.all([
+      scheduleIds.length
+        ? linkRepo.find({ where: { trainScheduleId: In(scheduleIds) } })
+        : Promise.resolve([]),
+      this.bookingsRepository.findAllBySchedules(scheduleIds),
+    ]);
+    const linkedIdsBySchedule = new Map<string, Set<string>>();
+    for (const l of allLinks) {
+      let set = linkedIdsBySchedule.get(l.trainScheduleId);
+      if (!set) linkedIdsBySchedule.set(l.trainScheduleId, (set = new Set()));
+      set.add(l.bookingId);
+    }
+    const bookingsBySchedule = new Map<string, Booking[]>();
+    for (const b of allBookings) {
+      if (!b.trainScheduleId) continue;
+      let list = bookingsBySchedule.get(b.trainScheduleId);
+      if (!list) bookingsBySchedule.set(b.trainScheduleId, (list = []));
+      list.push(b);
+    }
+
     const board: BatchBoardSchedule[] = [];
     for (const s of schedules) {
-      const links = await linkRepo.find({ where: { trainScheduleId: s.id } });
-      const linkedIds = new Set(links.map((l) => l.bookingId));
-      const bookings = await this.bookingsRepository.findAllBySchedule(s.id);
+      const linkedIds = linkedIdsBySchedule.get(s.id) ?? new Set<string>();
+      const bookings = bookingsBySchedule.get(s.id) ?? [];
 
       const items: BatchBoardBooking[] = bookings.map((b) => {
         const need = this.needFor(b, wagonDims);
@@ -1046,7 +1243,8 @@ export class BookingBatchService implements OnModuleInit {
     return { items: board, meta: buildPaginationMeta(total, page, pageSize) };
   }
 
-  /** Schedule-level batch board with EAT 3h windows grouped by fullyExecutedAt. */
+  /** Schedule-level batch board: the schedule's own booking window plus its
+   * bookings split into in-window (contract executed) vs pending-contract. */
   async getBatchBoardDetail(
     scheduleId: string,
   ): Promise<BatchBoardScheduleDetail> {
@@ -1064,17 +1262,24 @@ export class BookingBatchService implements OnModuleInit {
     }
 
     const wagonDims = await this.loadWagonDims();
-    const linkRepo = this.dataSource.getRepository(TrainScheduleBooking);
-    const links = await linkRepo.find({ where: { trainScheduleId: s.id } });
-    const linkedIds = new Set(links.map((l) => l.bookingId));
+    // The full graph already carries the schedule↔booking links — no separate
+    // link query needed.
+    const linkedIds = new Set(
+      (s.scheduleBookings ?? []).map((l) => l.bookingId),
+    );
     const bookings = await this.bookingsRepository.findAllBySchedule(s.id);
 
     let allocationPreview: Awaited<
       ReturnType<TrainSchedulingService["previewAllocationForSchedule"]>
     >;
     try {
+      // Reuse the graph loaded above — the preview otherwise re-loads the same
+      // heavy schedule graph a second time per request.
       allocationPreview =
-        await this.trainSchedulingService.previewAllocationForSchedule(s.id);
+        await this.trainSchedulingService.previewAllocationForSchedule(
+          s.id,
+          s,
+        );
     } catch {
       allocationPreview = {
         assignedBookingIds: [],
@@ -1144,73 +1349,22 @@ export class BookingBatchService implements OnModuleInit {
 
     const loco = s.trainSet?.locomotive ?? null;
 
-    // Display windows are the REAL booking-window cycles this schedule was FROZEN
-    // with at creation (import: opens at its stored window time, lasts its rule's
-    // duration, reopens per its rule's delay; export: single FCFS lead window) —
-    // NOT the live global config. A later global-rules edit only re-derives
-    // not-yet-open schedules (restampPendingWindows), so an already-open schedule
-    // must keep drawing from its own snapshot, anchored on its stored open time.
-    // Legacy rows with no snapshot fall back to the live config.
-    const liveCfg = await this.trainSchedulingService.getWindowConfig();
-    const num = (v: unknown, fallback: number) => {
-      const n = v == null ? NaN : Number(v);
-      return Number.isFinite(n) ? n : fallback;
-    };
-    const windowCfg = {
-      windowOpenHour: num(s.ruleWindowOpenHour, liveCfg.windowOpenHour),
-      windowCloseHour: num(s.ruleWindowCloseHour, liveCfg.windowCloseHour),
-      windowDurationHours: num(
-        s.ruleWindowDurationHours,
-        liveCfg.windowDurationHours,
-      ),
-      // Frozen doc-review + payment sum; legacy rows fall back to the live sum.
-      reopenGapMinutes: num(
-        s.ruleReopenDelayMinutes,
-        liveCfg.docReviewMinutes + liveCfg.paymentWindowMinutes,
-      ),
-      importWindowLeadDays: num(
-        s.ruleImportWindowLeadDays,
-        liveCfg.importWindowLeadDays,
-      ),
-      exportBookingLeadHours: num(
-        s.ruleExportBookingLeadHours,
-        liveCfg.exportBookingLeadHours,
-      ),
-      // Frozen close offsets: a snapshot null means "no offset for this train"
-      // and stays null (not the live offset); only legacy rows lacking the
-      // column (undefined) fall back to live config.
-      importCloseOffsetMinutes:
-        s.ruleImportCloseOffsetMinutes !== undefined
-          ? s.ruleImportCloseOffsetMinutes
-          : liveCfg.importCloseOffsetMinutes,
-      exportCloseOffsetMinutes:
-        s.ruleExportCloseOffsetMinutes !== undefined
-          ? s.ruleExportCloseOffsetMinutes
-          : liveCfg.exportCloseOffsetMinutes,
-    };
-    const departureDate = s.scheduledDepartureDate ?? new Date();
-    const windowBuckets = groupBookingsIntoBoardWindows(
-      items,
-      (item) => (item.fullyExecutedAt ? new Date(item.fullyExecutedAt) : null),
-      s.direction ?? null,
-      departureDate,
-      windowCfg,
-      undefined,
-      s.windowOpensAt ?? null,
-    );
-
-    const emptyCounts = () => ({
-      allocated: 0,
-      selectedForBatch: 0,
-      ready: 0,
-      waiting: 0,
-      expired: 0,
-      pendingContract: 0,
-    });
-
-    const countFor = (bookingsInWindow: BatchBoardBookingDetail[]) => {
-      const counts = emptyCounts();
-      for (const b of bookingsInWindow) {
+    // The board renders ONE booking window — the schedule's own frozen window
+    // (windowOpensAt/windowClosesAt + phase deadlines returned below). Bookings
+    // split into two buckets: contract executed (in the window) vs pending
+    // contract. The old per-cycle window projection was dropped — the UI never
+    // showed it, and reconstructing every cycle cost a config load + grouping
+    // pass per request.
+    const countFor = (bucket: BatchBoardBookingDetail[]): BatchBoardCounts => {
+      const counts: BatchBoardCounts = {
+        allocated: 0,
+        selectedForBatch: 0,
+        ready: 0,
+        waiting: 0,
+        expired: 0,
+        pendingContract: 0,
+      };
+      for (const b of bucket) {
         if (b.state === "ALLOCATED") counts.allocated += 1;
         else if (b.state === "SELECTED_FOR_BATCH") counts.selectedForBatch += 1;
         else if (b.state === "READY") counts.ready += 1;
@@ -1221,26 +1375,8 @@ export class BookingBatchService implements OnModuleInit {
       return counts;
     };
 
-    const windows: BatchWindowGroup[] = [];
-    for (const [key, bucket] of windowBuckets) {
-      if (key === "pending-contract" || !bucket.window) continue;
-      const w = bucket.window;
-      windows.push({
-        key: w.key,
-        label: w.label,
-        date: w.date,
-        dateLabel: w.dateLabel,
-        start: w.start.toISOString(),
-        end: w.end.toISOString(),
-        counts: countFor(bucket.items),
-        bookings: bucket.items,
-      });
-    }
-    windows.sort(
-      (a, b) => new Date(a.start).getTime() - new Date(b.start).getTime(),
-    );
-
-    const pendingBookings = windowBuckets.get("pending-contract")?.items ?? [];
+    const windowBookings = items.filter((i) => i.fullyExecutedAt);
+    const pendingBookings = items.filter((i) => !i.fullyExecutedAt);
 
     return {
       scheduleId: s.id,
@@ -1290,14 +1426,8 @@ export class BookingBatchService implements OnModuleInit {
           .length,
         expired: items.filter((i) => i.state === "EXPIRED").length,
       },
-      windows,
+      bookings: windowBookings,
       pendingContract: {
-        key: "pending-contract",
-        label: "Pending contract",
-        date: "",
-        dateLabel: "",
-        start: "",
-        end: "",
         counts: countFor(pendingBookings),
         bookings: pendingBookings,
       },
@@ -1852,15 +1982,23 @@ export class BookingBatchService implements OnModuleInit {
   }
 
   /**
-   * A lone commercial IMPORT booking on a GENERAL or ONE_TIME contract may be
-   * offered a partial (split-on-payment). Consolidated pairs never split (both-or-
-   * neither shared wagon) and government bookings never split (they preempt).
+   * A lone commercial booking on a GENERAL or ONE_TIME contract may be offered a
+   * partial (split-on-payment). Consolidated pairs never split (both-or-neither
+   * shared wagon) and government bookings never split (they preempt).
+   *
+   * IMPORT is always eligible. EXPORT is eligible only when export split is
+   * enabled: export historically rides one train whole, so splitting it changes
+   * the FCFS money path — each split part still rides ONE train whole, and the
+   * leftover becomes its own booking on the next train.
    */
   private isSplitEligible(booking: Booking, isPair: boolean): boolean {
+    const directionOk =
+      booking.tradeDirection === "IMPORT" ||
+      (booking.tradeDirection === "EXPORT" && this.exportSplitEnabled);
     return (
       !isPair &&
       !booking.isGovernment &&
-      booking.tradeDirection === "IMPORT" &&
+      directionOk &&
       (booking.contractKind === "GENERAL" || booking.contractKind === "ONE_TIME") &&
       this.splitService != null
     );
@@ -2323,7 +2461,13 @@ export class BookingBatchService implements OnModuleInit {
     if (!schedule || !locomotive) return null;
     const wagonDims = await this.loadWagonDims();
     const limits = await this.capacityLimits(locomotive);
-    const budget = await this.remainingBudget(schedule, limits, wagonDims);
+    // Built trains: collapse to a single train-wide pool so the freed capacity of
+    // a booking that alights mid-corridor is NOT re-offered on the pass-through
+    // leg (see remainingBudget). Keeps intercity accept consistent with the
+    // train-wide isTrainFull / committedWagons finalize signal.
+    const budget = await this.remainingBudget(schedule, limits, wagonDims, {
+      collapseForBuiltTrain: true,
+    });
     return { budget, needFor: (booking) => this.needFor(booking, wagonDims) };
   }
 
@@ -3117,7 +3261,14 @@ export class BookingBatchService implements OnModuleInit {
    * (NW5 flat for containers, CW3 gondola for bulk) for bookings whose type has
    * no wagon type configured yet.
    */
+  /** Wagon types are near-static reference data — a short TTL cache spares one
+   * table scan per board/detail request without letting edits go stale long. */
+  private wagonDimsCache: { value: WagonDims; expiresAt: number } | null = null;
+
   private async loadWagonDims(): Promise<WagonDims> {
+    if (this.wagonDimsCache && this.wagonDimsCache.expiresAt > Date.now()) {
+      return this.wagonDimsCache.value;
+    }
     const types = await this.dataSource.getRepository(WagonType).find();
     const byCode = new Map(
       types.map((t) => [t.code, wagonTypeDimensionsFromEntity(t)]),
@@ -3131,7 +3282,7 @@ export class BookingBatchService implements OnModuleInit {
     // must fall back rather than yield an infinite wagon count.
     const payload = (value: number | undefined, fallback: number): number =>
       value && value > 0 ? value : fallback;
-    return {
+    const value: WagonDims = {
       container: {
         lengthMeters: nw5?.lengthMeters ?? DEFAULT_CONTAINER_WAGON_LENGTH_METERS,
         tareWeightTons: nw5?.tareWeightTons ?? DEFAULT_CONTAINER_WAGON_TARE_TONS,
@@ -3144,6 +3295,8 @@ export class BookingBatchService implements OnModuleInit {
       },
       byWagonTypeId,
     };
+    this.wagonDimsCache = { value, expiresAt: Date.now() + 60_000 };
+    return value;
   }
 
   /**
@@ -3174,6 +3327,40 @@ export class BookingBatchService implements OnModuleInit {
     };
   }
 
+  /**
+   * EVERY wagon-type dimension a booking may ride — its cargo/container type's
+   * full allowed (many-to-many) wagon-type list, not just the first like
+   * {@link dimsFor}. The remainder placer needs the whole set so a train that
+   * stocks a non-primary allowed type still counts as fitting: a container type
+   * mapped to both NW5 and (say) NW7 must be measured against whichever a given
+   * train actually has free. Deduped by wagon-type id; falls back to the single
+   * representative dims when no allowed type is configured.
+   */
+  private dimsForAllowed(booking: Booking, wagonDims: WagonDims): PerWagonDims[] {
+    const fallback =
+      booking.freightType === "BULK" ? wagonDims.bulk : wagonDims.container;
+    const ids =
+      booking.freightType === "BULK"
+        ? (booking.cargoType?.wagonTypes ?? []).map((wt) => wt.id)
+        : (booking.bookingContainers ?? [])
+            .flatMap((line) => line.containerType?.wagonTypes ?? [])
+            .map((wt) => wt.id);
+    const seen = new Set<string>();
+    const dims: PerWagonDims[] = [];
+    for (const id of ids) {
+      if (!id || seen.has(id)) continue;
+      seen.add(id);
+      const d = wagonDims.byWagonTypeId.get(id);
+      if (d) {
+        dims.push({
+          ...d,
+          capacityTons: d.capacityTons > 0 ? d.capacityTons : fallback.capacityTons,
+        });
+      }
+    }
+    return dims.length ? dims : [fallback];
+  }
+
   /**
    * Ordered stop yards of the schedule's route (origin → milestones →
    * destination); the legacy two-stop pseudo-route when milestones are absent.
@@ -3211,6 +3398,7 @@ export class BookingBatchService implements OnModuleInit {
     schedule: TrainSchedule,
     limits: TrainLimits,
     wagonDims: WagonDims,
+    opts?: { collapseForBuiltTrain?: boolean },
   ): Promise<CorridorBudget> {
     const physicalWagons = await this.builtTrainWagonCount(schedule);
     if (physicalWagons != null) {
@@ -3223,7 +3411,21 @@ export class BookingBatchService implements OnModuleInit {
         tolerance: { weightTons: 0, lengthMeters: 0 },
       };
     }
-    const stops = await this.stopsForSchedule(schedule);
+    // A built train's wagons are coupled for the WHOLE trip, and the allocator
+    // commits each booking to a wagon for the entire route — it never reloads a
+    // wagon at a mid-corridor alight yard. So a built train has no leg concept:
+    // its capacity is one train-wide pool, exactly as isTrainFull /
+    // committedWagons already count it. When a caller opts in, collapse the
+    // corridor to a single whole-route edge so every booking (full-route OR
+    // mid-corridor) draws from that one pool — a train full of import-to-DireDawa
+    // then correctly shows NO room for a DireDawa->Addis intercity booking on the
+    // leg it merely passes through, instead of over-promising the freed slots.
+    // Locomotive-derived schedules keep the leg-aware multi-edge corridor: their
+    // abstract slot/weight/length budget genuinely frees past an alight yard.
+    const stops =
+      physicalWagons != null && opts?.collapseForBuiltTrain
+        ? [schedule.originStationId, schedule.destinationStationId]
+        : await this.stopsForSchedule(schedule);
     const budget = new CorridorBudget(stops, limits.base, limits.tolerance);
     const allocated = (schedule.scheduleBookings ?? [])
       .map((sb) => sb.booking)
@@ -3385,11 +3587,19 @@ export class BookingBatchService implements OnModuleInit {
 
   /** See {@link isScheduleFull} — same check for callers that already hold the full graph. */
   private async isTrainFull(schedule: TrainSchedule): Promise<boolean> {
+    // Built train: the physical consist is the only capacity axis, and a wagon
+    // is committed to its booking for the WHOLE trip — wagon allocation has no
+    // leg concept, so a wagon hauling Negad→Mojo cargo can never be re-sold for
+    // the Doraleh→Negad edge it merely passes through. Count commitments
+    // train-wide, not per corridor edge: the per-edge budget read "free slots"
+    // on pass-through legs of a sold-out consist, so the window of a full train
+    // cycled OPEN forever instead of concluding DONE (and the day pool's
+    // leftover bookings were never expired).
+    const physicalWagons = await this.builtTrainWagonCount(schedule);
+    if (physicalWagons != null) {
+      return (await this.committedWagons(schedule)) >= physicalWagons;
+    }
     if ((await this.remainingWagons(schedule)) <= 0) return true;
-    // Built train: the physical consist is the only capacity axis. Weight and
-    // length were enforced when the consist was assembled (builder /
-    // adjust-consist), so a free wagon slot means the train genuinely has room.
-    if ((await this.builtTrainWagonCount(schedule)) != null) return false;
     const locomotive = schedule.trainSet?.locomotive;
     if (!locomotive) return false; // no weight/length limits to bind against
     const wagonDims = await this.loadWagonDims();
@@ -3398,6 +3608,29 @@ export class BookingBatchService implements OnModuleInit {
     return budget.isExhausted(this.minPerWagonNeed(wagonDims));
   }
 
+  /**
+   * Wagons the schedule's allocated + reserved bookings occupy train-wide,
+   * regardless of which corridor leg each rides. Deduped by booking id — a
+   * booking mid-settle can momentarily be both linked and reserved.
+   */
+  private async committedWagons(schedule: TrainSchedule): Promise<number> {
+    const wagonDims = await this.loadWagonDims();
+    const allocated = (schedule.scheduleBookings ?? [])
+      .map((sb) => sb.booking)
+      .filter((b): b is Booking => Boolean(b));
+    const reserved = await this.bookingsRepository.findReservedForSchedule(
+      schedule.id,
+    );
+    const byId = new Map(
+      [...allocated, ...reserved].map((b) => [b.id, b] as const),
+    );
+    let total = 0;
+    for (const booking of byId.values()) {
+      total += this.wagonsFor(booking, wagonDims);
+    }
+    return total;
+  }
+
   /**
    * Smallest gross weight / shortest length one more wagon could add: the
    * lightest wagon type at its rated payload. Feeds CorridorBudget.isExhausted,
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 6f366d060..fb140158c 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
@@ -352,10 +352,19 @@ export class BookingJourneyService {
   ): Promise<void> {
     if (booking.tradeDirection !== 'DOMESTIC') return;
     const facility = await this.yardFacilities.facilityForYard(yardId);
+    const where = side === 'origin' ? 'loaded at its origin' : 'unloaded at its destination';
+
     if (!facility?.hasFacility) {
       throw new BadRequestException(
-        `${facility?.yardLabel ?? 'This yard'} has no load/unload facility — an intercity booking cannot be ` +
-          `${side === 'origin' ? 'loaded at its origin' : 'unloaded at its destination'} here.`,
+        `${facility?.yardLabel ?? 'This yard'} has no load/unload facility — an intercity booking cannot be ${where} here.`,
+      );
+    }
+    // A facility only handles what its equipment can lift: containers need a
+    // reach stacker/gantry, bulk does not.
+    if (!this.yardFacilities.canHandleFreight(facility, booking.freightType)) {
+      throw new BadRequestException(
+        `${facility.yardLabel ?? 'This yard'} does not handle ${String(booking.freightType).toLowerCase()} cargo — ` +
+          `an intercity booking cannot be ${where} here.`,
       );
     }
   }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
index 3d505e113..e17445b4d 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
@@ -150,10 +150,18 @@ export class BookingNotifierService {
   ): Promise<void> {
     const payMinutes = Math.max(1, Math.round((deadline.getTime() - Date.now()) / 60_000));
     const eat = deadline.toLocaleString('en-GB', { timeZone: 'Africa/Addis_Ababa' });
+    const leftover = totalWagons - offeredWagons;
+    // With auto-placement on, the leftover is booked FOR the customer on another
+    // train (its own invoice) — telling them to rebook it themselves would be
+    // wrong. Without it, the leftover returns to the contract to rebook.
+    const leftoverCopy =
+      process.env.FREIGHT_AUTO_REMAINDER === 'true'
+        ? `The remaining ${leftover} will be booked for you on another train, with its own invoice. `
+        : `The remaining ${leftover} return${leftover === 1 ? 's' : ''} to your contract — book them yourself in a later window. `;
     const msg =
       `Only ${offeredWagons} of ${totalWagons} wagons fit the train for booking ${b.reference ?? b.id}. ` +
       `Pay within ${payMinutes} minute${payMinutes === 1 ? '' : 's'} to accept and ship ${offeredWagons} wagon${offeredWagons === 1 ? '' : 's'} now. ` +
-      `The remaining ${totalWagons - offeredWagons} return${totalWagons - offeredWagons === 1 ? 's' : ''} to your contract — book them yourself in a later window. ` +
+      leftoverCopy +
       `If you do not pay, the booking stays whole and you can rebook in the next window. Deadline: ${eat} EAT.`;
     await this.notifyContact(b, msg, 'PAY NOW (PARTIAL)');
     // HIGH: a split is a change to what the customer ordered AND a live payment
@@ -164,6 +172,23 @@ export class BookingNotifierService {
     });
   }
 
+  /**
+   * The wagons that did not fit the train the customer just paid for have been
+   * auto-booked as their own booking (`remainder`) — they ride another train and
+   * are billed separately. Sent instead of leaving the customer to rebook.
+   */
+  remainderPlaced(remainder: Booking, parentReference: string): void {
+    const msg =
+      `The wagons left over from booking ${parentReference} have been booked as ` +
+      `${remainder.reference ?? remainder.id} on another train. ` +
+      `It carries its own invoice — pay it to secure that slot.`;
+    void this.notifyContact(remainder, msg, 'REMAINDER BOOKED');
+    this.inApp(remainder, 'Leftover wagons booked', msg, {
+      type: NotificationType.INVOICE_ISSUED,
+      priority: NotificationPriority.HIGH,
+    });
+  }
+
   secured(b: Booking, reason: 'paid' | 'gov', scheduleId?: string | null): void {
     void (async () => {
       const label = await this.scheduleLabel(scheduleId ?? b.trainScheduleId);
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/record-checkpoint.dto.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/record-checkpoint.dto.spec.ts
new file mode 100644
index 000000000..58cf5da12
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/record-checkpoint.dto.spec.ts
@@ -0,0 +1,37 @@
+import { plainToInstance } from 'class-transformer';
+import { validate } from 'class-validator';
+
+import { RecordCheckpointDto } from './record-checkpoint.dto';
+
+const validateBody = (body: Record<string, unknown>) =>
+  validate(plainToInstance(RecordCheckpointDto, body));
+
+describe('RecordCheckpointDto', () => {
+  // The final checkpoint arrives the schedule, so a backdated one rewrites the
+  // journey after the fact. No UI sends occurredAt; the endpoint still accepts it.
+  it('rejects a backdated occurredAt', async () => {
+    const errors = await validateBody({
+      sequenceNo: 3,
+      occurredAt: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+    });
+
+    expect(errors).toHaveLength(1);
+    expect(errors[0].property).toBe('occurredAt');
+    expect(errors[0].constraints).toHaveProperty('IsNotBackdated');
+  });
+
+  it('accepts occurredAt of now', async () => {
+    const errors = await validateBody({
+      sequenceNo: 3,
+      occurredAt: new Date().toISOString(),
+    });
+
+    expect(errors).toHaveLength(0);
+  });
+
+  it('accepts a body that omits occurredAt, leaving the service to stamp it', async () => {
+    const errors = await validateBody({ sequenceNo: 0 });
+
+    expect(errors).toHaveLength(0);
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/record-checkpoint.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/record-checkpoint.dto.ts
index 7f778760d..da7ebc0e7 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/dto/record-checkpoint.dto.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/record-checkpoint.dto.ts
@@ -10,6 +10,8 @@ import {
   Min,
 } from 'class-validator';
 
+import { IsNotBackdated } from '../../../common/validators/is-not-backdated.validator';
+
 export class RecordCheckpointDto {
   @ApiProperty({ description: 'Station position along the route (0 = origin).' })
   @IsInt()
@@ -21,9 +23,18 @@ export class RecordCheckpointDto {
   @IsEnum(TrainCheckpointKind)
   kind?: TrainCheckpointKind;
 
-  @ApiProperty({ required: false, description: 'ISO timestamp; defaults to now.' })
+  /**
+   * A checkpoint records where the train is as staff observe it, and the final
+   * one arrives the schedule — so a backdated value rewrites the journey after
+   * the fact. Only "now" is accepted; omit the field and the service stamps it.
+   */
+  @ApiProperty({
+    required: false,
+    description: 'ISO timestamp; defaults to now. Cannot be earlier than now.',
+  })
   @IsOptional()
   @IsISO8601()
+  @IsNotBackdated()
   occurredAt?: string;
 
   @ApiProperty({ required: false })
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
index f54dc138e..b35650e16 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
@@ -67,10 +67,18 @@ export class IntercityService {
               ts.status                   AS "scheduleStatus",
               oy.id                       AS "originYardId",
               COALESCE(oy.label, oy.code) AS "origin",
-              oy.has_facility             AS "originHasFacility",
+              -- Can that end actually handle THIS booking's cargo? A container
+              -- booking needs a facility with a stacker; bulk needs any facility.
+              (oy.has_facility AND COALESCE(
+                 CASE WHEN b.freight_type = 'CONTAINER'
+                      THEN ofac.handles_container ELSE ofac.handles_bulk END, false))
+                                          AS "originHasFacility",
               dy.id                       AS "destinationYardId",
               COALESCE(dy.label, dy.code) AS "destination",
-              dy.has_facility             AS "destinationHasFacility",
+              (dy.has_facility AND COALESCE(
+                 CASE WHEN b.freight_type = 'CONTAINER'
+                      THEN dfac.handles_container ELSE dfac.handles_bulk END, false))
+                                          AS "destinationHasFacility",
               -- Where the train actually is, so the operator knows if the cargo
               -- can be worked right now.
               cp.yard_id                  AS "trainAtYardId",
@@ -80,6 +88,10 @@ export class IntercityService {
          LEFT JOIN freight.companies company ON company.id = b.company_id
          LEFT JOIN freight.yards oy ON oy.id = b.origin_yard_id
          LEFT JOIN freight.yards dy ON dy.id = b.destination_yard_id
+         LEFT JOIN freight.yard_facilities ofac
+           ON ofac.yard_id = oy.id AND ofac.deleted_at IS NULL AND ofac.is_active = true
+         LEFT JOIN freight.yard_facilities dfac
+           ON dfac.yard_id = dy.id AND dfac.deleted_at IS NULL AND dfac.is_active = true
          LEFT JOIN freight.train_schedules ts
            ON ts.id = b.train_schedule_id AND ts.deleted_at IS NULL
          LEFT JOIN LATERAL (
@@ -104,7 +116,8 @@ export class IntercityService {
 
   async listCandidates(scheduleId: string) {
     const schedule = await this.getSchedule(scheduleId);
-    const milestoneSeq = await this.routeMilestoneSequence(schedule);
+    const milestones = await this.routeMilestones(schedule);
+    const milestoneSeq = this.milestoneSequenceOf(schedule, milestones);
     const capacity = await this.bookingBatchService.intercityCapacity(scheduleId);
 
     const waiting = milestoneSeq
@@ -112,29 +125,45 @@ export class IntercityService {
       : [];
     const accepted = await this.findAcceptedIntercityBookings(scheduleId);
 
+    // Mid-corridor intercity matching needs a real stop list (>= 2 route
+    // milestones). Without one the fallback is a 2-stop origin->destination
+    // pseudo-route that only matches bookings on the train's exact corridor —
+    // surface that so an empty candidate list isn't misread as "nobody waiting".
+    const warning =
+      milestoneSeq == null
+        ? 'This schedule has no route or origin/destination set, so no intercity corridors can be served.'
+        : schedule.routeId && milestones.length < 2
+          ? "This schedule's route has no stop list (needs at least 2 route milestones), so mid-corridor intercity bookings cannot be matched — only bookings on the train's exact origin→destination will appear."
+          : null;
+
     return {
       scheduleId,
       routeId: schedule.routeId ?? null,
+      warning,
       // Segment-based: "remaining" is the most-open edge; each candidate's
       // `fits` is judged against ITS OWN leg, so a booking on a free leg fits
       // even when the train is full elsewhere.
       remaining: capacity?.budget.maxRemaining() ?? null,
       candidates: waiting.map((booking) => {
         const need = capacity?.needFor(booking) ?? null;
-        const leg = capacity?.budget.legOf(
+        // legForYards, not legOf: on a built train the budget is a single
+        // whole-route edge (see intercityCapacity), so a mid-corridor booking
+        // must draw from that one pool via the whole-route fallback. On a
+        // locomotive-derived schedule it still resolves to the booking's own leg.
+        const leg = capacity?.budget.legForYards(
           booking.originYardId,
           booking.destinationYardId,
         );
         return {
-          ...this.mapBooking(booking),
+          ...this.mapBooking(booking, need),
           need,
           fits: Boolean(need && capacity && leg && capacity.budget.fits(need, leg)),
         };
       }),
-      accepted: accepted.map((booking) => ({
-        ...this.mapBooking(booking),
-        need: capacity?.needFor(booking) ?? null,
-      })),
+      accepted: accepted.map((booking) => {
+        const need = capacity?.needFor(booking) ?? null;
+        return { ...this.mapBooking(booking, need), need };
+      }),
     };
   }
 
@@ -186,14 +215,17 @@ export class IntercityService {
         continue;
       }
       const need = capacity.needFor(booking);
-      const leg = budget.legOf(booking.originYardId, booking.destinationYardId);
-      // Segment-based: only the booking's own leg must have room, so an
-      // intercity booking still boards a train that is full on other legs.
-      if (!leg || !budget.fits(need, leg)) {
+      // legForYards, not legOf: a built train's budget is a single whole-route
+      // pool (mid-corridor wagons are committed for the whole trip and never
+      // reloaded), so the booking draws from that pool via the whole-route
+      // fallback; a locomotive-derived schedule still gets the booking's own
+      // leg, so it can still board a train that is full only on other legs.
+      const leg = budget.legForYards(booking.originYardId, booking.destinationYardId);
+      if (!budget.fits(need, leg)) {
         rejected.push({
           bookingId,
           reason:
-            'Does not fit the remaining wagon/weight/length capacity on its leg',
+            'Does not fit the remaining wagon/weight/length capacity for this train',
         });
         continue;
       }
@@ -244,16 +276,21 @@ export class IntercityService {
    * so an intercity booking exactly matching the train's own corridor still
    * qualifies.
    */
-  private async routeMilestoneSequence(
+  private async routeMilestones(
     schedule: TrainSchedule,
-  ): Promise<Map<string, number> | null> {
-    if (schedule.routeId) {
-      const milestones = await this.dataSource
-        .getRepository(RouteMilestone)
-        .find({ where: { routeId: schedule.routeId }, order: { sequenceNo: 'ASC' } });
-      if (milestones.length >= 2) {
-        return new Map(milestones.map((m) => [m.yardId, m.sequenceNo]));
-      }
+  ): Promise<RouteMilestone[]> {
+    if (!schedule.routeId) return [];
+    return this.dataSource
+      .getRepository(RouteMilestone)
+      .find({ where: { routeId: schedule.routeId }, order: { sequenceNo: 'ASC' } });
+  }
+
+  private milestoneSequenceOf(
+    schedule: TrainSchedule,
+    milestones: RouteMilestone[],
+  ): Map<string, number> | null {
+    if (milestones.length >= 2) {
+      return new Map(milestones.map((m) => [m.yardId, m.sequenceNo]));
     }
     if (schedule.originStationId && schedule.destinationStationId) {
       return new Map([
@@ -264,6 +301,15 @@ export class IntercityService {
     return null;
   }
 
+  private async routeMilestoneSequence(
+    schedule: TrainSchedule,
+  ): Promise<Map<string, number> | null> {
+    return this.milestoneSequenceOf(
+      schedule,
+      await this.routeMilestones(schedule),
+    );
+  }
+
   /** Waiting = ready intercity bookings not yet on any train, corridor on this route. */
   private async findWaitingIntercityBookings(
     milestoneSeq: Map<string, number>,
@@ -356,7 +402,12 @@ export class IntercityService {
     return { schedule, booking };
   }
 
-  private mapBooking(booking: Booking) {
+  /**
+   * `need` carries the GROSS weight (cargo + wagon tare) the capacity budget is
+   * spent in. Prefer it, so the row's weight sits on the same axis as the
+   * remaining-capacity figure shown beside it; cargo VGM is the fallback.
+   */
+  private mapBooking(booking: Booking, need?: { weightTons: number } | null) {
     return {
       id: booking.id,
       reference: booking.reference,
@@ -372,7 +423,7 @@ export class IntercityService {
         booking.destinationYard?.label ??
         booking.destinationYard?.code ??
         'Unknown destination',
-      weightTons: Number(booking.cargoTotalWeightVgm ?? 0),
+      weightTons: need?.weightTons ?? Number(booking.cargoTotalWeightVgm ?? 0),
       paymentDeadline: booking.paymentDeadline?.toISOString() ?? null,
     };
   }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.spec.ts
new file mode 100644
index 000000000..55cacaf03
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.spec.ts
@@ -0,0 +1,211 @@
+import { RemainderPlacementService } from './remainder-placement.service';
+
+/**
+ * The remainder placer reconstructs the outstanding split remainder as a new
+ * booking. The delicate parts under test: bulk sizes from the outstanding tons;
+ * container recovers real numbers from the SOFT-DELETED units (never fabricates)
+ * and throws on a shortfall; and nothing is placed when there's no outstanding
+ * or no fitting train.
+ */
+describe('RemainderPlacementService', () => {
+  const DAY = '2026-07-20';
+
+  function make(opts: {
+    freightType: 'CONTAINER' | 'BULK';
+    contractKind?: 'ONE_TIME' | 'GENERAL';
+    outstanding: unknown;
+    createThrows?: Error;
+    deferredUnits?: Array<{
+      containerNumber: string;
+      vgmTons: number;
+      isHazardous?: boolean;
+      isReefer?: boolean;
+    }>;
+    fittingTrains?: Array<{ scheduleId: string }>;
+  }) {
+    const contract = {
+      id: 'c-1',
+      freightType: opts.freightType,
+      contractKind: opts.contractKind ?? 'ONE_TIME',
+    };
+    const contractsRepository = {
+      findByIdWithRelations: jest.fn().mockResolvedValue(contract),
+    };
+    const createUnderContract = opts.createThrows
+      ? jest.fn().mockRejectedValue(opts.createThrows)
+      : jest
+          .fn()
+          .mockResolvedValue({ booking: { id: 'rem-1', reference: 'BKG-R' }, warnings: [] });
+    const contractBookingService = {
+      splitOutstanding: jest.fn().mockResolvedValue(opts.outstanding),
+      createUnderContract,
+    };
+    const bookingBatchService = {
+      fittingTrainsForDay: jest
+        .fn()
+        .mockResolvedValue(opts.fittingTrains ?? [{ scheduleId: 's-2' }]),
+    };
+    // getRepository is only hit on the container path (recoverDeferredUnits).
+    const lineRepo = {
+      find: jest.fn().mockResolvedValue([{ id: 'line-1' }]),
+    };
+    const unitRepo = {
+      find: jest.fn().mockResolvedValue(opts.deferredUnits ?? []),
+    };
+    const dataSource = {
+      getRepository: jest.fn((entity: { name?: string }) => {
+        const n = entity?.name ?? '';
+        if (n.includes('Unit')) return unitRepo;
+        return lineRepo;
+      }),
+    };
+    const notifier = { remainderPlaced: jest.fn() };
+    const service = new RemainderPlacementService(
+      dataSource as never,
+      contractsRepository as never,
+      contractBookingService as never,
+      bookingBatchService as never,
+      notifier as never,
+    );
+    return {
+      service,
+      createUnderContract,
+      contractBookingService,
+      bookingBatchService,
+      notifier,
+    };
+  }
+
+  const splitBooking = {
+    id: 'bk-1',
+    reference: 'BKG-1',
+    contractId: 'c-1',
+    scheduledDate: new Date('2026-07-20T06:00:00Z'),
+    createdByUserId: 'u-1',
+  } as never;
+
+  it('sizes a BULK remainder from the outstanding tons', async () => {
+    const { service, createUnderContract } = make({
+      freightType: 'BULK',
+      outstanding: { bySize: new Map(), bulk: { total: 100, outstanding: 40 } },
+    });
+    const id = await service.placeRemainder(splitBooking);
+    expect(id).toBe('rem-1');
+    const dto = createUnderContract.mock.calls[0][1];
+    expect(dto.bulkLines).toEqual([{ cargoWeightTons: 40 }]);
+    expect(dto.scheduledDate).toBe(DAY);
+  });
+
+  it('rebuilds a CONTAINER remainder from the soft-deleted units', async () => {
+    const deferredUnits = [
+      { containerNumber: 'ABCD1234567', vgmTons: 12, isReefer: true },
+      { containerNumber: 'ABCD7654321', vgmTons: 10, isHazardous: true },
+    ];
+    const { service, createUnderContract } = make({
+      freightType: 'CONTAINER',
+      outstanding: {
+        bySize: new Map([['40ft', { total: 5, outstanding: 2 }]]),
+        bulk: null,
+      },
+      deferredUnits,
+    });
+    const id = await service.placeRemainder(splitBooking);
+    expect(id).toBe('rem-1');
+    const dto = createUnderContract.mock.calls[0][1];
+    expect(dto.containers).toHaveLength(1);
+    const line = dto.containers[0];
+    expect(line.containerSize).toBe('40ft');
+    expect(line.quantity).toBe(2);
+    expect(line.units.map((u: { containerNumber: string }) => u.containerNumber)).toEqual([
+      'ABCD1234567',
+      'ABCD7654321',
+    ]);
+    expect(line.reeferQuantity).toBe(1);
+    expect(line.hazardousQuantity).toBe(1);
+  });
+
+  it('throws (→ no placement) when fewer units are recoverable than outstanding — never fabricates', async () => {
+    const { service, createUnderContract } = make({
+      freightType: 'CONTAINER',
+      outstanding: {
+        bySize: new Map([['40ft', { total: 5, outstanding: 3 }]]),
+        bulk: null,
+      },
+      deferredUnits: [{ containerNumber: 'ABCD1234567', vgmTons: 12 }], // only 1, need 3
+    });
+    const id = await service.placeRemainder(splitBooking);
+    expect(id).toBeNull();
+    expect(createUnderContract).not.toHaveBeenCalled();
+  });
+
+  it('is a no-op when there is no outstanding remainder', async () => {
+    const { service, createUnderContract } = make({
+      freightType: 'BULK',
+      outstanding: { bySize: new Map(), bulk: { total: 100, outstanding: 0 } },
+    });
+    const id = await service.placeRemainder(splitBooking);
+    expect(id).toBeNull();
+    expect(createUnderContract).not.toHaveBeenCalled();
+  });
+
+  it('tells the customer the leftover wagons were booked on another train', async () => {
+    const { service, notifier } = make({
+      freightType: 'BULK',
+      outstanding: { bySize: new Map(), bulk: { total: 100, outstanding: 40 } },
+    });
+    await service.placeRemainder(splitBooking);
+    expect(notifier.remainderPlaced).toHaveBeenCalledWith(
+      expect.objectContaining({ id: 'rem-1' }),
+      'BKG-1',
+    );
+  });
+
+  it('never double-books the leftover when two payments land together', async () => {
+    const { service, createUnderContract } = make({
+      freightType: 'BULK',
+      outstanding: { bySize: new Map(), bulk: { total: 100, outstanding: 40 } },
+    });
+    // Both callers enter before either create commits.
+    await Promise.all([
+      service.placeRemainder(splitBooking),
+      service.placeRemainder(splitBooking),
+    ]);
+    expect(createUnderContract).toHaveBeenCalledTimes(1);
+  });
+
+  // splitOutstanding subtracts a CONTRACT-WIDE booked total from ONE booking's
+  // snapshot — coherent only for ONE_TIME. On GENERAL that mixes scopes and
+  // either drops a real remainder or double-draws the cap, so we must not place.
+  it('never auto-places on a GENERAL contract (cap ledger mismatch)', async () => {
+    const { service, createUnderContract, contractBookingService } = make({
+      freightType: 'BULK',
+      contractKind: 'GENERAL',
+      outstanding: { bySize: new Map(), bulk: { total: 100, outstanding: 40 } },
+    });
+    const id = await service.placeRemainder(splitBooking);
+    expect(id).toBeNull();
+    expect(createUnderContract).not.toHaveBeenCalled();
+    expect(contractBookingService.splitOutstanding).not.toHaveBeenCalled();
+  });
+
+  // The paid booking has already boarded — a create-gate rejection (e.g. the
+  // export whole-train gate) must leave the remainder rebookable, not escape.
+  it('swallows a create rejection and leaves the remainder for manual rebook', async () => {
+    const { service } = make({
+      freightType: 'BULK',
+      outstanding: { bySize: new Map(), bulk: { total: 100, outstanding: 40 } },
+      createThrows: new Error('Not enough train space for this day.'),
+    });
+    await expect(service.placeRemainder(splitBooking)).resolves.toBeNull();
+  });
+
+  it('is a no-op when the contract has no split chain', async () => {
+    const { service, createUnderContract } = make({
+      freightType: 'BULK',
+      outstanding: null,
+    });
+    const id = await service.placeRemainder(splitBooking);
+    expect(id).toBeNull();
+    expect(createUnderContract).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.ts
new file mode 100644
index 000000000..85b6d0878
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.ts
@@ -0,0 +1,342 @@
+import { Injectable, Logger, forwardRef, Inject } from '@nestjs/common';
+import { DataSource, IsNull, Not } from 'typeorm';
+
+import { Booking } from '../bookings/entities/booking.entity';
+import { BookingContainer } from '../bookings/entities/booking-container.entity';
+import { BookingContainerUnit } from '../bookings/entities/booking-container-unit.entity';
+import { Contract } from '../contracts/entities/contract.entity';
+import {
+  ContractBookingService,
+  SplitOutstanding,
+} from '../contracts/contract-booking.service';
+import { ContractsRepository } from '../contracts/contracts.repository';
+import {
+  CreateBookingUnderContractDto,
+  CreateContainerUnitDto,
+} from '../contracts/dto/create-booking-under-contract.dto';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
+import { BookingBatchService } from './booking-batch.service';
+import { BookingNotifierService } from './booking-notifier.service';
+import { eatDay } from './batch-window.util';
+
+/**
+ * Auto-creates and places the OUTSTANDING split remainder of a contract as a new
+ * booking, so the customer doesn't have to manually rebook the wagons that did
+ * not fit the train they just paid for.
+ *
+ * Fired (feature-flagged) right after `applySplit` runs on payment — i.e. only
+ * once the customer has actually accepted+paid the offered part. Before payment
+ * nothing is split: the booking stays whole and the customer may still edit or
+ * cancel it. See the split lifecycle in {@link BookingSplitService.applySplit}.
+ *
+ * IMPORT/DOMESTIC: the remainder booking is created with the next fitting
+ * shipment day set and then follows the normal windowed batch flow (train
+ * assigned at window close, paid in its own window). It is NOT force-reserved on
+ * a specific train — import is not FCFS.
+ *
+ * Container reconstruction is HYBRID: the remainder's quantities come from the
+ * split snapshot (`splitOutstanding`), but the actual container numbers / VGM /
+ * seals are read back from the units `applySplit` SOFT-DELETED off the parent
+ * (they survive as valid ISO records). We never `restore()` those rows — the new
+ * booking gets fresh rows — so the contract cap is never double-counted.
+ */
+@Injectable()
+export class RemainderPlacementService {
+  private readonly logger = new Logger(RemainderPlacementService.name);
+
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly contractsRepository: ContractsRepository,
+    @Inject(forwardRef(() => ContractBookingService))
+    private readonly contractBookingService: ContractBookingService,
+    @Inject(forwardRef(() => BookingBatchService))
+    private readonly bookingBatchService: BookingBatchService,
+    private readonly notifier: BookingNotifierService,
+  ) {}
+
+  /**
+   * Create + place the outstanding split remainder of the contract that owns
+   * `splitBooking`. No-op when there is no live remainder or no fitting day.
+   * Returns the created remainder booking id, or null when nothing was placed
+   * (residual falls back to the customer's manual rebook, as today).
+   */
+  async placeRemainder(splitBooking: Booking): Promise<string | null> {
+    if (!splitBooking.contractId) return null;
+    // Two payment webhooks for the same contract landing together would both see
+    // the remainder as unbooked (the placing create has not committed yet) and
+    // each create one — double-booking the leftover. Serialize per contract: the
+    // second caller returns immediately and the first one's create is what the
+    // (now smaller) outstanding reflects.
+    if (this.inFlight.has(splitBooking.contractId)) {
+      this.logger.debug(
+        `Remainder placement already running for contract ${splitBooking.contractId} — skipped.`,
+      );
+      return null;
+    }
+    this.inFlight.add(splitBooking.contractId);
+    try {
+      return await this.placeRemainderInner(splitBooking);
+    } finally {
+      this.inFlight.delete(splitBooking.contractId);
+    }
+  }
+
+  /** Contracts with a placement in flight — see {@link placeRemainder}. */
+  private readonly inFlight = new Set<string>();
+
+  private async placeRemainderInner(
+    splitBooking: Booking,
+  ): Promise<string | null> {
+    const contract = await this.contractsRepository.findByIdWithRelations(
+      splitBooking.contractId!,
+    );
+    if (!contract) return null;
+
+    // ONE_TIME only. `splitOutstanding` subtracts a CONTRACT-WIDE booked total
+    // from a SINGLE booking's pre-split snapshot, which is only coherent when
+    // the contract has exactly one live chain — that is the ONE_TIME invariant
+    // (enforced by hasSplitBooking → assertExactRemainder). On a GENERAL
+    // contract with other live bookings the subtraction mixes scopes: it either
+    // clamps to 0 and silently drops a real remainder, or sizes one that then
+    // draws the quantity cap a second time. GENERAL remainders keep the existing
+    // manual-rebook behaviour until the remainder can be derived from the
+    // offer's own dropped lines rather than from the contract-wide ledger.
+    if (contract.contractKind !== 'ONE_TIME') {
+      this.logger.debug(
+        `Contract ${contract.id} is ${contract.contractKind} — remainder left ` +
+          `for manual rebook (auto-placement is ONE_TIME only).`,
+      );
+      return null;
+    }
+
+    const outstanding = await this.contractBookingService.splitOutstanding(
+      contract,
+    );
+    if (!outstanding || !this.hasOutstanding(contract, outstanding)) {
+      return null;
+    }
+
+    // The next fitting day: the earliest day on/after the split booking's own day
+    // that still has an import train with room for this cargo type. We reuse the
+    // split booking as the capacity probe — it carries the leg + cargo relations.
+    const day = await this.nextFittingDay(splitBooking);
+    if (!day) {
+      this.logger.warn(
+        `No train with room for the remainder of contract ${contract.id} ` +
+          `(booking ${splitBooking.reference}) — left for manual rebook.`,
+      );
+      return null;
+    }
+
+    let dto: CreateBookingUnderContractDto;
+    try {
+      dto = await this.buildRemainderDto(
+        contract,
+        outstanding,
+        splitBooking.id,
+        day,
+      );
+    } catch (err) {
+      // A reconstruction shortfall (fewer recoverable units than outstanding)
+      // must NOT fabricate container numbers — fail loudly, leave manual rebook.
+      this.logger.error(
+        `Could not reconstruct the remainder of contract ${contract.id}: ` +
+          `${err instanceof Error ? err.message : String(err)} — left for manual rebook.`,
+      );
+      return null;
+    }
+
+    // Any create-gate rejection (no train space, cap, container clash) must not
+    // escape: the customer's paid booking has already boarded, and a thrown
+    // error here would only be logged upstream while the remainder vanished
+    // silently. Fall back to leaving it rebookable, which is the pre-feature
+    // behaviour, and say so in the log.
+    let created: Awaited<
+      ReturnType<ContractBookingService['createUnderContract']>
+    >;
+    try {
+      created = await this.contractBookingService.createUnderContract(
+        contract.id,
+        dto,
+        { id: splitBooking.createdByUserId ?? undefined },
+        // System actor: a permission-bag carrying the contract create-booking key
+        // so the GL gate (isGlActor → hasFreightPermission) passes for GL Path B
+        // contracts; harmless for customer (Path A) contracts.
+        { permissions: [{ key: FREIGHT_PERMS.contracts.createBooking }] },
+      );
+    } catch (err) {
+      this.logger.error(
+        `Could not create the remainder booking for contract ${contract.id} ` +
+          `(from ${splitBooking.reference}): ${
+            err instanceof Error ? err.message : String(err)
+          } — left for manual rebook.`,
+      );
+      return null;
+    }
+    // EXPORT is FCFS — there is no window to wait for, so the remainder is
+    // reserved on the next export train right away (its own pay window opens).
+    // If it does not fit one train whole either, the export accept offers it a
+    // partial and the chain repeats on ITS payment: each pass leaves a strictly
+    // smaller remainder, so it terminates at the day's train count.
+    // IMPORT/DOMESTIC deliberately does NOT force a train: it carries the next
+    // fitting day and rides the normal windowed batch flow.
+    if (splitBooking.tradeDirection === 'EXPORT') {
+      const fresh = await this.dataSource
+        .getRepository(Booking)
+        .findOne({
+          where: { id: created.booking.id },
+          relations: {
+            company: true,
+            bookingContainers: { containerType: true },
+            cargoType: true,
+          },
+        });
+      if (fresh) {
+        await this.bookingBatchService
+          .acceptExportBooking(fresh)
+          .catch((err) =>
+            // No export train took it — it stays created and rebookable, which
+            // is the same place a customer-driven rebook would leave it.
+            this.logger.warn(
+              `Export remainder ${fresh.reference} created but not reserved: ${
+                err instanceof Error ? err.message : String(err)
+              }`,
+            ),
+          );
+      }
+    }
+
+    this.notifier.remainderPlaced(
+      created.booking,
+      splitBooking.reference ?? splitBooking.id,
+    );
+    this.logger.log(
+      `Auto-placed split remainder of contract ${contract.id} as booking ` +
+        `${created.booking.reference} on ${day}.`,
+    );
+    return created.booking.id;
+  }
+
+  private hasOutstanding(
+    contract: Contract,
+    outstanding: SplitOutstanding,
+  ): boolean {
+    if (contract.freightType === 'CONTAINER') {
+      return [...outstanding.bySize.values()].some((s) => s.outstanding > 0);
+    }
+    return (outstanding.bulk?.outstanding ?? 0) > 0.001;
+  }
+
+  /**
+   * The shipment day to create the remainder on — the split booking's own day.
+   *
+   * EXPORT is FCFS and must actually board a train that day, so a day with NO
+   * export train having room is rejected (null → left for manual rebook on a day
+   * the customer picks). IMPORT/DOMESTIC keeps the day regardless: its train is
+   * assigned by the batch engine at window close, not now, and the window may
+   * still free up — forcing a different day here would override the customer's
+   * binding shipment day.
+   */
+  private async nextFittingDay(booking: Booking): Promise<string | null> {
+    if (!booking.scheduledDate) return null;
+    const day = eatDay(new Date(booking.scheduledDate));
+    if (booking.tradeDirection !== 'EXPORT') return day;
+
+    const fitting = await this.bookingBatchService.fittingTrainsForDay(
+      booking,
+      day,
+      'EXPORT',
+    );
+    return fitting.length > 0 ? day : null;
+  }
+
+  /**
+   * Build the create-DTO for the WHOLE outstanding remainder. Bulk uses the
+   * outstanding tonnage directly. Container reads the deferred (soft-deleted)
+   * units of the split booking back into real unit records.
+   */
+  private async buildRemainderDto(
+    contract: Contract,
+    outstanding: SplitOutstanding,
+    splitBookingId: string,
+    day: string,
+  ): Promise<CreateBookingUnderContractDto> {
+    const dto: CreateBookingUnderContractDto = { scheduledDate: day };
+
+    if (contract.freightType !== 'CONTAINER') {
+      const tons = outstanding.bulk?.outstanding ?? 0;
+      dto.bulkLines = [{ cargoWeightTons: tons }];
+      return dto;
+    }
+
+    // Container: recover the deferred units per size from the split booking's
+    // soft-deleted rows and reshape into DTO units.
+    const containers: NonNullable<CreateBookingUnderContractDto['containers']> = [];
+    for (const [size, { outstanding: need }] of outstanding.bySize) {
+      if (need <= 0) continue;
+      const units = await this.recoverDeferredUnits(splitBookingId, size, need);
+      if (units.length < need) {
+        throw new Error(
+          `size ${size}: recovered ${units.length} deferred container(s) but ` +
+            `${need} are outstanding`,
+        );
+      }
+      const line: NonNullable<CreateBookingUnderContractDto['containers']>[number] = {
+        containerSize: size,
+        quantity: need,
+        units,
+      };
+      line.hazardousQuantity = units.filter((u) => u.isHazardous).length;
+      line.reeferQuantity = units.filter((u) => u.isReefer).length;
+      containers.push(line);
+    }
+    dto.containers = containers;
+    return dto;
+  }
+
+  /**
+   * The `need` deferred container units of a given size for the split booking,
+   * read from the SOFT-DELETED unit rows (oldest sortOrder first — mirroring the
+   * LIFO trim in applySplit so the same physical containers deferred are the
+   * ones rebooked). Returns them as DTO units; does NOT restore the rows.
+   */
+  private async recoverDeferredUnits(
+    splitBookingId: string,
+    containerSize: string,
+    need: number,
+  ): Promise<CreateContainerUnitDto[]> {
+    // The line ids of this booking for this size (live + soft-deleted): units
+    // key on bookingContainerId, so gather every line of the size first.
+    const lines = await this.dataSource
+      .getRepository(BookingContainer)
+      .find({
+        where: { bookingId: splitBookingId, containerSize },
+        withDeleted: true,
+        select: { id: true },
+      });
+    const lineIds = lines.map((l) => l.id);
+    if (!lineIds.length) return [];
+
+    // Only the DELETED units are the deferred ones (live units stayed on the
+    // paid part). Oldest-first to match the deferred set.
+    const deferred = await this.dataSource
+      .getRepository(BookingContainerUnit)
+      .find({
+        where: lineIds.map((bookingContainerId) => ({
+          bookingContainerId,
+          deletedAt: Not(IsNull()),
+        })),
+        withDeleted: true,
+        order: { sortOrder: 'ASC', createdAt: 'ASC' },
+        take: need,
+      });
+
+    return deferred.map((u) => ({
+      containerNumber: u.containerNumber,
+      sealNumber: u.sealNumber ?? undefined,
+      vgmTons: Number(u.vgmTons),
+      isHazardous: u.isHazardous,
+      isReefer: u.isReefer,
+    }));
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
index 6bc36c4fc..3e142f778 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.controller.ts
@@ -139,7 +139,8 @@ export class TrainSchedulingController {
   @Get("batch-board/:scheduleId")
   @TrainSchedulingView()
   @ApiOperation({
-    summary: "Batch board detail for one schedule with EAT 3h windows",
+    summary:
+      "Batch board detail for one schedule: its booking window, in-window bookings and pending-contract bucket",
   })
   getBatchBoardDetail(@Param("scheduleId", ParseUUIDPipe) scheduleId: string) {
     return this.bookingBatchService.getBatchBoardDetail(scheduleId);
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
index fa8623b4a..35503d432 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.module.ts
@@ -34,6 +34,7 @@ import { IntercityService } from './intercity.service';
 import { WsAuthService } from '../notification-inbox/ws-auth.service';
 import { BookingJourneyService } from './booking-journey.service';
 import { BookingSplitService } from './booking-split.service';
+import { RemainderPlacementService } from './remainder-placement.service';
 import { BookingBatchOffer } from './entities/booking-batch-offer.entity';
 import { WagonMovement } from '../wagons/entities/wagon-movement.entity';
 import { NotificationsModule } from '../notifications/notifications.module';
@@ -82,6 +83,7 @@ import { ContractsModule } from '../contracts/contracts.module';
     WsAuthService,
     BookingWindowService,
     BookingSplitService,
+    RemainderPlacementService,
     IntercityService,
     BookingJourneyService,
     FacilityHandlingService,
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
index c0ff19b25..af1a9eb45 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-scheduling.service.spec.ts
@@ -965,4 +965,120 @@ describe('TrainSchedulingService', () => {
       expect(result).toHaveLength(2);
     });
   });
+
+  describe('marshalling documents', () => {
+    // Staff check these against the physical consist, so every wagon on the
+    // train set has to appear — an empty wagon that renders no row reads as a
+    // wagon that is not on the train.
+    const makeWagon = (sequenceNo: number, wagonNumber: string, allocations: unknown[]) => ({
+      sequenceNo,
+      wagonNumber,
+      physicalWagon: { wagonNumber },
+      wagonType: { code: 'NW5', name: 'Flat Wagon', tareWeightTons: 22 },
+      lengthMeters: 14,
+      capacityTons: 70,
+      allocations,
+    });
+
+    const loadedAllocation = {
+      bookingId: 'booking-1',
+      bookingReference: 'BK-2026-000001',
+      loadType: 'CONTAINER',
+      allocatedWeightTons: 24.5,
+      containerNumbers: ['CONT-001'],
+      booking: { id: 'booking-1', reference: 'BK-2026-000001', companyId: 'company-1' },
+      containerItems: [{ containerNumber: 'CONT-001', sealNumber: 'SEAL-1', chassisNumber: 'CH-1' }],
+    };
+
+    const countRows = (html: string) => (html.match(/<tr(?: class="empty")?>\s*<td/g) ?? []).length;
+
+    it('lists an empty wagon on the export document and marks it EMPTY', () => {
+      const schedule = {
+        id: 'schedule-1',
+        trainNumber: '8302',
+        direction: 'EXPORT',
+        trainSet: {
+          wagons: [
+            makeWagon(1, 'W-001', [loadedAllocation]),
+            makeWagon(2, 'W-002', []),
+            makeWagon(3, 'W-003', []),
+          ],
+        },
+        scheduleBookings: [],
+      };
+
+      const html = (service as never as {
+        buildExportLoadListHtml: (s: unknown) => string;
+      }).buildExportLoadListHtml(schedule);
+
+      expect(countRows(html)).toBe(3);
+      expect(html).toContain('W-002');
+      expect(html).toContain('W-003');
+      expect(html.match(/EMPTY — no cargo allocated/g)).toHaveLength(2);
+      // The wagon count must agree with the rows the reader can see.
+      expect(html).toContain('3 (2 empty)');
+    });
+
+    it('lists an empty wagon on the import document and marks it EMPTY', () => {
+      const loadList = {
+        generatedAt: '2026-07-17T08:00:00.000Z',
+        trainScheduleId: 'schedule-1',
+        trainNumber: '8002',
+        route: 'Djibouti → Indode',
+        origin: 'Djibouti Port',
+        destination: 'Indode',
+        totalBookings: 1,
+        wagons: [
+          { sequenceNo: 1, wagonNumber: 'W-001', allocations: [loadedAllocation] },
+          { sequenceNo: 2, wagonNumber: 'W-002', allocations: [] },
+        ],
+        operation: { status: {} },
+      };
+
+      const html = (service as never as {
+        buildImportLoadListHtml: (l: unknown) => string;
+      }).buildImportLoadListHtml(loadList);
+
+      expect(countRows(html)).toBe(2);
+      expect(html).toContain('W-002');
+      expect(html.match(/EMPTY — no cargo allocated/g)).toHaveLength(1);
+      expect(html).toContain('2 (1 empty)');
+    });
+
+    it('renders wagons in consist order regardless of the order the relation returns', () => {
+      const schedule = {
+        id: 'schedule-1',
+        trainNumber: '8302',
+        direction: 'EXPORT',
+        trainSet: {
+          wagons: [makeWagon(3, 'W-003', []), makeWagon(1, 'W-001', []), makeWagon(2, 'W-002', [])],
+        },
+        scheduleBookings: [],
+      };
+
+      const html = (service as never as {
+        buildExportLoadListHtml: (s: unknown) => string;
+      }).buildExportLoadListHtml(schedule);
+
+      expect(html.indexOf('W-001')).toBeLessThan(html.indexOf('W-002'));
+      expect(html.indexOf('W-002')).toBeLessThan(html.indexOf('W-003'));
+    });
+
+    it('omits the empty-count suffix when every wagon is loaded', () => {
+      const schedule = {
+        id: 'schedule-1',
+        trainNumber: '8302',
+        direction: 'EXPORT',
+        trainSet: { wagons: [makeWagon(1, 'W-001', [loadedAllocation])] },
+        scheduleBookings: [],
+      };
+
+      const html = (service as never as {
+        buildExportLoadListHtml: (s: unknown) => string;
+      }).buildExportLoadListHtml(schedule);
+
+      expect(html).not.toContain('empty)');
+      expect(html).not.toContain('EMPTY');
+    });
+  });
 });
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 eb3fd7201..9d426077e 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
@@ -267,6 +267,8 @@ export interface CompositionUnassignedBookingRow {
   freightType: string | null;
   priorityScore: number;
   cargoTotalWeightVgm: number;
+  /** GROSS: cargo VGM + tare of every wagon the booking occupies. */
+  grossWeightTons: number;
   status: string | null;
   schedulingStatus: string | null;
   wagonsRequired: number;
@@ -477,6 +479,38 @@ export class TrainSchedulingService {
     return qb.getMany();
   }
 
+  /**
+   * A built train makes at most ONE departure per route per EAT day. Returns
+   * the non-cancelled schedule already holding this train on this route for
+   * `departure`'s EAT day, or null when the day is free. Route+day GROUPS stay
+   * legal — siblings must be different trains.
+   */
+  private async findTrainRouteDayConflict(
+    trainId: string,
+    routeId: string,
+    departure: Date,
+    excludeScheduleId?: string,
+  ): Promise<TrainSchedule | null> {
+    const day = eatDay(departure);
+    const dayStart = eatDayToUtc(day, 0);
+    const nextDayStart = eatDayToUtc(shiftEatDay(day, 1), 0);
+    const qb = this.dataSource
+      .getRepository(TrainSchedule)
+      .createQueryBuilder('s')
+      .innerJoin('s.trainSet', 'ts')
+      .where('ts.trainId = :trainId', { trainId })
+      .andWhere('s.routeId = :routeId', { routeId })
+      .andWhere('s.scheduledDepartureDate >= :dayStart', { dayStart })
+      .andWhere('s.scheduledDepartureDate < :nextDayStart', { nextDayStart })
+      .andWhere('s.status != :cancelledStatus', {
+        cancelledStatus: TrainScheduleStatusEnum.Cancelled,
+      });
+    if (excludeScheduleId) {
+      qb.andWhere('s.id != :excludeScheduleId', { excludeScheduleId });
+    }
+    return qb.getOne();
+  }
+
   /**
    * The window timeline a brand-new schedule must adopt to join its route+day
    * group. Returns the canonical open/close times + rule snapshot copied from an
@@ -880,6 +914,28 @@ export class TrainSchedulingService {
       );
     }
 
+    // Moving onto a day where this same built train already runs this route
+    // would double-book the physical train — blocked for planning moves.
+    if (schedule.trainSetId && schedule.routeId) {
+      const trainSet = await this.dataSource
+        .getRepository(TrainSet)
+        .findOne({ where: { id: schedule.trainSetId } });
+      if (trainSet?.trainId) {
+        const conflict = await this.findTrainRouteDayConflict(
+          trainSet.trainId,
+          schedule.routeId,
+          departure,
+          id,
+        );
+        if (conflict) {
+          throw new ConflictException(
+            `This train is already scheduled on this route for that day ` +
+              `(${conflict.reference ?? conflict.id}) — one departure per route per day`,
+          );
+        }
+      }
+    }
+
     // Re-derive the window from the schedule's own rule snapshot (falling back to
     // the live config where a legacy row has no snapshot) against the new date.
     const merged = effectiveWindowConfig(schedule, windowCfg);
@@ -913,10 +969,37 @@ export class TrainSchedulingService {
       scheduledDepartureDate: departure,
       ...windowFields,
     });
+
+    // Only customers whose bookings already HOLD wagons on this train are told
+    // about the move (SMS + email + portal inbox). Linked-but-unallocated
+    // bookings are skipped — nothing of theirs is riding this departure yet.
+    let notifiedCount = 0;
+    if (schedule.trainSetId) {
+      const allocations = await this.dataSource
+        .getRepository(WagonBookingAllocation)
+        .createQueryBuilder('a')
+        .innerJoin('a.trainSetWagon', 'slot')
+        .where('slot.trainSetId = :trainSetId', { trainSetId: schedule.trainSetId })
+        .getMany();
+      const allocatedBookingIds = [...new Set(allocations.map((a) => a.bookingId))];
+      if (allocatedBookingIds.length) {
+        const allocatedBookings = await this.dataSource.getRepository(Booking).find({
+          where: { id: In(allocatedBookingIds) },
+          relations: { company: true },
+        });
+        for (const booking of allocatedBookings) {
+          if (['CANCELLED', 'EXPIRED', 'REJECTED'].includes(booking.status)) continue;
+          this.bookingNotifier.rescheduled(booking, departure);
+          notifiedCount += 1;
+        }
+      }
+    }
+
     this.logger.log(
       `Departure date changed for schedule ${id} → ${departure.toISOString()} ` +
         `(window reopens ${windowFields.windowOpensAt?.toISOString() ?? 'n/a'}` +
-        `${anchor ? `, joined route+day group anchor ${anchor.id}` : ''})`,
+        `${anchor ? `, joined route+day group anchor ${anchor.id}` : ''}); ` +
+        `${notifiedCount} allocated customer booking(s) notified`,
     );
     void this.emitWindowState(id);
 
@@ -1200,7 +1283,8 @@ export class TrainSchedulingService {
       }
       if (
         builtTrain.status === Freight.TrainStatus.OutOfService ||
-        builtTrain.status === Freight.TrainStatus.UnderMaintenance
+        builtTrain.status === Freight.TrainStatus.UnderMaintenance ||
+        builtTrain.status === Freight.TrainStatus.Deactivated
       ) {
         throw new ConflictException(
           `Train ${builtTrain.code} is ${builtTrain.status.toLowerCase().replace(/_/g, ' ')}`,
@@ -1220,6 +1304,17 @@ export class TrainSchedulingService {
           `Train ${builtTrain.code} is not at the origin yard yet; it must arrive before this departure dispatches`,
         );
       }
+      const conflict = await this.findTrainRouteDayConflict(
+        builtTrain.id,
+        route.id,
+        new Date(dto.scheduleDate),
+      );
+      if (conflict) {
+        throw new ConflictException(
+          `Train ${builtTrain.code} is already scheduled on this route for that day ` +
+            `(${conflict.reference ?? conflict.id}) — one departure per route per day`,
+        );
+      }
     } else {
       locomotiveIds = [...new Set(dto.locomotiveIds ?? [])];
       if (locomotiveIds.length < 2) {
@@ -1679,6 +1774,7 @@ export class TrainSchedulingService {
         scheduleId,
         schedule.originStationId,
         savedWagons,
+        schedule.reverseWagonOrder ?? false,
       );
     });
 
@@ -2590,19 +2686,24 @@ export class TrainSchedulingService {
       origin: schedule.originStation?.label ?? schedule.originStation?.code ?? null,
       destination: schedule.destinationStation?.label ?? schedule.destinationStation?.code ?? null,
       totalBookings: schedule.scheduleBookings?.length ?? 0,
-      wagons: (schedule.trainSet?.wagons ?? []).map((wagon) => ({
-        sequenceNo: wagon.sequenceNo,
-        wagonNumber: wagon.physicalWagon?.wagonNumber ?? null,
-        allocations: (wagon.allocations ?? []).map((allocation) => ({
-          bookingId: allocation.bookingId,
-          bookingReference: allocation.booking?.reference ?? null,
-          loadType: allocation.loadType ?? null,
-          allocatedWeightTons: Number(allocation.allocatedWeightTons) || 0,
-          containerNumbers: (allocation.containerItems ?? [])
-            .map((item) => item.containerNumber)
-            .filter(Boolean),
+      // Every wagon on the train set, loaded or not, in consist order. An empty
+      // wagon has an empty `allocations` array — it is still part of the train
+      // and still belongs on the marshalling document.
+      wagons: [...(schedule.trainSet?.wagons ?? [])]
+        .sort((a, b) => Number(a.sequenceNo ?? 0) - Number(b.sequenceNo ?? 0))
+        .map((wagon) => ({
+          sequenceNo: wagon.sequenceNo,
+          wagonNumber: wagon.physicalWagon?.wagonNumber ?? null,
+          allocations: (wagon.allocations ?? []).map((allocation) => ({
+            bookingId: allocation.bookingId,
+            bookingReference: allocation.booking?.reference ?? null,
+            loadType: allocation.loadType ?? null,
+            allocatedWeightTons: Number(allocation.allocatedWeightTons) || 0,
+            containerNumbers: (allocation.containerItems ?? [])
+              .map((item) => item.containerNumber)
+              .filter(Boolean),
+          })),
         })),
-      })),
       operation: await this.getImportDjiboutiOperation(schedule.id),
     };
   }
@@ -2652,9 +2753,33 @@ export class TrainSchedulingService {
     const date = (value: unknown) => (value ? new Date(value as string | Date).toLocaleDateString('en-GB') : '-');
     const time = (value: unknown) => (value ? new Date(value as string | Date).toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' }) : '-');
     const bookingById = new Map((schedule.scheduleBookings ?? []).map((link) => [link.bookingId, link.booking]));
-    const rows = (schedule.trainSet?.wagons ?? [])
-      .flatMap((wagon) =>
-        (wagon.allocations ?? []).map((allocation) => {
+    // The document is checked against the physical train, so it has to run in
+    // consist order — the relation comes back unordered.
+    const wagons = [...(schedule.trainSet?.wagons ?? [])].sort(
+      (a, b) => Number(a.sequenceNo ?? 0) - Number(b.sequenceNo ?? 0),
+    );
+    const rows = wagons
+      .flatMap((wagon) => {
+        // Wagon identity is the same on every row the wagon produces, loaded or not.
+        const wagonCells = `<td>${esc(wagon.sequenceNo)}</td>
+            <td>${esc(wagon.physicalWagon?.wagonNumber)}</td>
+            <td>${esc(wagon.wagonType?.code ?? wagon.wagonType?.name)}</td>
+            <td class="num">${esc(Number(wagon.lengthMeters || 0).toFixed(3))}</td>
+            <td class="num">${esc(Number(wagon.wagonType?.tareWeightTons ?? 0).toFixed(2))}</td>
+            <td class="num">${esc(Number(wagon.capacityTons || 0).toFixed(3))}</td>`;
+        const allocations = wagon.allocations ?? [];
+        // An empty wagon still runs in the consist, so it still gets a line. Staff
+        // check this document against the physical train — a wagon with no row
+        // reads as a wagon that is not there, and the count stops matching.
+        if (allocations.length === 0) {
+          return [
+            `<tr class="empty">
+            ${wagonCells}
+            <td colspan="6">EMPTY — no cargo allocated</td>
+          </tr>`,
+          ];
+        }
+        return allocations.map((allocation) => {
           const booking = allocation.booking ?? bookingById.get(allocation.bookingId);
           const company = booking?.company as Record<string, unknown> | null | undefined;
           const cargoType = (booking as unknown as { cargoType?: { name?: string; code?: string } } | undefined)?.cargoType;
@@ -2664,12 +2789,7 @@ export class TrainSchedulingService {
           const sealNumbers = containerItems.map((item) => item.sealNumber).filter(Boolean).join(', ');
           const chassisNumbers = containerItems.map((item) => item.chassisNumber).filter(Boolean).join(', ');
           return `<tr>
-            <td>${esc(wagon.sequenceNo)}</td>
-            <td>${esc(wagon.physicalWagon?.wagonNumber)}</td>
-            <td>${esc(wagon.wagonType?.code ?? wagon.wagonType?.name)}</td>
-            <td class="num">${esc(Number(wagon.lengthMeters || 0).toFixed(3))}</td>
-            <td class="num">${esc(Number(wagon.wagonType?.tareWeightTons ?? 0).toFixed(2))}</td>
-            <td class="num">${esc(Number(wagon.capacityTons || 0).toFixed(3))}</td>
+            ${wagonCells}
             <td>${esc(company?.name ?? company?.legalName ?? company?.tradeName ?? booking?.companyId)}</td>
             <td>${esc(booking?.companyId)}</td>
             <td>${esc(cargoType?.name ?? cargoType?.code ?? allocation.loadType)}</td>
@@ -2677,10 +2797,11 @@ export class TrainSchedulingService {
             <td>${esc(chassisNumbers)}</td>
             <td>${esc(sealNumbers)}</td>
           </tr>`;
-        }),
-      )
+        });
+      })
       .join('');
-    const totalWeight = (schedule.trainSet?.wagons ?? []).reduce(
+    const emptyWagons = wagons.filter((wagon) => (wagon.allocations ?? []).length === 0).length;
+    const totalWeight = wagons.reduce(
       (sum, wagon) =>
         sum + (wagon.allocations ?? []).reduce((wagonSum, allocation) => wagonSum + Number(allocation.allocatedWeightTons || 0), 0),
       0,
@@ -2708,6 +2829,8 @@ export class TrainSchedulingService {
     th { background: #f8fafc; color: #475569; text-align: left; }
     th, td { border: 1px solid #cbd5e1; padding: 5px 6px; font-size: 9.5px; vertical-align: top; }
     .num { text-align: right; }
+    tr.empty td { background: #f8fafc; color: #64748b; }
+    tr.empty td[colspan] { font-weight: 700; letter-spacing: .04em; }
     .notice { margin-top: 10px; border-left: 4px solid #0f766e; background: #f0fdfa; padding: 8px 10px; font-size: 10px; color: #134e4a; }
     .signatures { display: grid; grid-template-columns: repeat(3, 1fr); gap: 18px; margin-top: 34px; }
     .line { border-top: 1px solid #334155; padding-top: 7px; font-size: 9px; color: #475569; min-height: 34px; }
@@ -2735,7 +2858,7 @@ export class TrainSchedulingService {
     <div class="tile"><span>Total loaded weight</span><strong>${esc(totalWeight.toFixed(3))} T</strong></div>
     <div class="tile"><span>Prepared person</span><strong>${esc(schedule.preparedByUserId)}</strong></div>
     <div class="tile"><span>Check person</span><strong>${esc(schedule.checkedByUserId)}</strong></div>
-    <div class="tile"><span>Wagons</span><strong>${esc(schedule.trainSet?.wagons?.length ?? 0)}</strong></div>
+    <div class="tile"><span>Wagons</span><strong>${esc(wagons.length)}${emptyWagons ? ` (${emptyWagons} empty)` : ''}</strong></div>
     <div class="tile"><span>Bookings</span><strong>${esc(schedule.scheduleBookings?.length ?? 0)}</strong></div>
     <div class="tile"><span>Status</span><strong>${esc(schedule.status)}</strong></div>
     <div class="tile"><span>Direction</span><strong>${esc(schedule.direction)}</strong></div>
@@ -2759,7 +2882,7 @@ export class TrainSchedulingService {
       </tr>
     </thead>
     <tbody>
-      ${rows || '<tr><td colspan="12">No wagon allocations found for this export train.</td></tr>'}
+      ${rows || '<tr><td colspan="12">No wagons on this train set.</td></tr>'}
     </tbody>
   </table>
 
@@ -2802,19 +2925,31 @@ export class TrainSchedulingService {
         sum + wagon.allocations.reduce((wagonSum, allocation) => wagonSum + Number(allocation.allocatedWeightTons || 0), 0),
       0,
     );
+    const emptyWagons = loadList.wagons.filter((wagon) => wagon.allocations.length === 0).length;
     const allocationRows = loadList.wagons
-      .flatMap((wagon) =>
-        wagon.allocations.map(
+      .flatMap((wagon) => {
+        const wagonCells = `<td>${esc(wagon.sequenceNo)}</td>
+            <td>${esc(wagon.wagonNumber)}</td>`;
+        // An empty wagon still runs in the consist, so it still gets a line — see
+        // buildExportLoadListHtml.
+        if (wagon.allocations.length === 0) {
+          return [
+            `<tr class="empty">
+            ${wagonCells}
+            <td colspan="4">EMPTY — no cargo allocated</td>
+          </tr>`,
+          ];
+        }
+        return wagon.allocations.map(
           (allocation) => `<tr>
-            <td>${esc(wagon.sequenceNo)}</td>
-            <td>${esc(wagon.wagonNumber)}</td>
+            ${wagonCells}
             <td>${esc(allocation.bookingReference ?? allocation.bookingId)}</td>
             <td>${esc(allocation.loadType)}</td>
             <td>${esc(allocation.containerNumbers.length ? allocation.containerNumbers.join(', ') : '-')}</td>
             <td class="num">${esc(Number(allocation.allocatedWeightTons || 0).toFixed(3))}</td>
           </tr>`,
-        ),
-      )
+        );
+      })
       .join('');
 
     return `<!doctype html>
@@ -2846,6 +2981,8 @@ export class TrainSchedulingService {
     th { background: #f8fafc; color: #475569; text-align: left; }
     th, td { border: 1px solid #cbd5e1; padding: 7px 8px; font-size: 11px; vertical-align: top; }
     .num { text-align: right; }
+    tr.empty td { background: #f8fafc; color: #64748b; }
+    tr.empty td[colspan] { font-weight: 700; letter-spacing: .04em; }
     .notice { margin-top: 16px; border-left: 4px solid #0f766e; background: #f0fdfa; padding: 10px 12px; font-size: 11px; color: #134e4a; }
     .signatures { display: grid; grid-template-columns: 1fr 1fr 1fr; gap: 22px; margin-top: 44px; }
     .line { border-top: 1px solid #334155; padding-top: 8px; font-size: 10px; color: #475569; min-height: 42px; }
@@ -2872,7 +3009,7 @@ export class TrainSchedulingService {
       <div class="tile"><span>Origin</span><strong>${esc(loadList.origin)}</strong></div>
       <div class="tile"><span>Destination</span><strong>${esc(loadList.destination)}</strong></div>
       <div class="tile"><span>Total bookings</span><strong>${esc(loadList.totalBookings)}</strong></div>
-      <div class="tile"><span>Wagons</span><strong>${esc(loadList.wagons.length)}</strong></div>
+      <div class="tile"><span>Wagons</span><strong>${esc(loadList.wagons.length)}${emptyWagons ? ` (${emptyWagons} empty)` : ''}</strong></div>
       <div class="tile"><span>Allocations</span><strong>${esc(totalAllocations)}</strong></div>
       <div class="tile"><span>Total weight</span><strong>${esc(totalWeight.toFixed(3))} T</strong></div>
       <div class="tile"><span>Gatepass granted</span><strong>${esc(date(loadList.operation.gatepassGrantedAt))}</strong></div>
@@ -2900,7 +3037,7 @@ export class TrainSchedulingService {
         </tr>
       </thead>
       <tbody>
-        ${allocationRows || '<tr><td colspan="6">No wagon allocations found for this train.</td></tr>'}
+        ${allocationRows || '<tr><td colspan="6">No wagons on this train set.</td></tr>'}
       </tbody>
     </table>
 
@@ -3866,11 +4003,18 @@ export class TrainSchedulingService {
     }
 
     const totalWeightTons = totalAssignedWeight(fittingBookings);
+    // Every weight limit below (global max, loco pull) is a GROSS axis, so the
+    // figure spent against it must be gross too — cargo alone under-reports the
+    // train by the full consist tare and disagrees with the assign path.
+    const totalTareTons = roundTons(
+      wagonPlan.reduce((sum, w) => sum + (Number(w.tareWeightTons) || 0), 0),
+    );
+    const grossWeightTons = roundTons(totalWeightTons + totalTareTons);
     const totalLengthMeters = roundTons(
       wagonPlan.reduce((sum, w) => sum + w.lengthMeters, 0),
     );
-    if (totalWeightTons > trainLimits.maxWeightTons) {
-      const message = `Total booking weight ${totalWeightTons}T exceeds max train weight ${trainLimits.maxWeightTons}T`;
+    if (grossWeightTons > trainLimits.maxWeightTons) {
+      const message = `Total gross weight ${grossWeightTons}T (${totalWeightTons}T cargo + ${totalTareTons}T wagon tare) exceeds max train weight ${trainLimits.maxWeightTons}T`;
       if (!violations.includes(message) && !warnings.includes(message)) {
         pushLimit([message]);
       }
@@ -3897,7 +4041,7 @@ export class TrainSchedulingService {
       if (
         setLimits &&
         (setLimits.maxPullWeightTons + (Number(setLimits.overageToleranceTons) || 0) <
-          totalWeightTons ||
+          grossWeightTons ||
           setLimits.maxTrainLengthMeters + (Number(setLimits.overageToleranceMeters) || 0) <
             totalLengthMeters)
       ) {
@@ -3918,7 +4062,7 @@ export class TrainSchedulingService {
         !inServiceLocomotives.some(
           (l) =>
             Number(l.maxPullWeightTons) + (Number(l.overageToleranceTons) || 0) >=
-              totalWeightTons &&
+              grossWeightTons &&
             Number(l.maxTrainLengthMeters) + (Number(l.overageToleranceMeters) || 0) >=
               totalLengthMeters,
         )
@@ -3940,6 +4084,9 @@ export class TrainSchedulingService {
       summary: {
         totalBookings: fittingBookings.length,
         totalWeightTons,
+        /** GROSS: cargo + the tare of every wagon in the plan. */
+        grossWeightTons,
+        totalTareTons,
         // Human-readable wagon type(s) of the plan — mixed consists list all.
         wagonType: plannedTypeCodes.join('/') || 'NONE',
         wagonsNeeded: wagonPlan.length,
@@ -4271,6 +4418,7 @@ export class TrainSchedulingService {
     scheduleId: string,
     originYardId: string,
     slots: TrainSetWagon[],
+    reverseWagonOrder = false,
   ) {
     const wagons = await manager.getRepository(Wagon).find();
     const wagonTypes = await manager.getRepository(WagonType).find();
@@ -4316,6 +4464,7 @@ export class TrainSchedulingService {
         assignedPhysicalIds,
         builtTrainId,
         pinnedToScheduleIds,
+        reverseWagonOrder,
       );
       if (!physical) continue;
 
@@ -4409,6 +4558,7 @@ export class TrainSchedulingService {
     assignedPhysicalIds: Set<string>,
     builtTrainId: string | null = null,
     pinnedToScheduleIds: Set<string> = new Set(),
+    reverseWagonOrder = false,
   ): Wagon | undefined {
     const usable = (wagon: Wagon): boolean => {
       if (wagon.wagonTypeId !== slot.wagonTypeId) return false;
@@ -4429,12 +4579,26 @@ export class TrainSchedulingService {
     // wherever they currently sit (they travel with the train), never a loose
     // yard wagon.
     if (builtTrainId) {
-      return wagons.find(
-        (w) =>
-          w.trainId === builtTrainId &&
-          w.wagonTypeId === slot.wagonTypeId &&
-          !assignedPhysicalIds.has(w.id),
-      );
+      // Pin in the train's as-built coupling order (wagon.sequenceNumber) so the
+      // consist views draw the schedule exactly like the train builder; a schedule
+      // created with reverseWagonOrder pins back-to-front (physically-last wagon
+      // takes slot #1). Unsequenced wagons sort after every sequenced one.
+      const candidates = wagons
+        .filter(
+          (w) =>
+            w.trainId === builtTrainId &&
+            w.wagonTypeId === slot.wagonTypeId &&
+            !assignedPhysicalIds.has(w.id),
+        )
+        .sort((a, b) => {
+          if (a.sequenceNumber == null || b.sequenceNumber == null) {
+            return (a.sequenceNumber == null ? 1 : 0) - (b.sequenceNumber == null ? 1 : 0);
+          }
+          return reverseWagonOrder
+            ? b.sequenceNumber - a.sequenceNumber
+            : a.sequenceNumber - b.sequenceNumber;
+        });
+      return candidates[0];
     }
     // Prefer a wagon already waiting at the slot's board yard (no empty haul);
     // fall back to one riding from the train's origin.
@@ -5097,7 +5261,11 @@ export class TrainSchedulingService {
     const trains = await this.dataSource.getRepository(Train).find({
       where: {
         status: Not(
-          In([Freight.TrainStatus.OutOfService, Freight.TrainStatus.UnderMaintenance]),
+          In([
+            Freight.TrainStatus.OutOfService,
+            Freight.TrainStatus.UnderMaintenance,
+            Freight.TrainStatus.Deactivated,
+          ]),
         ),
       },
       relations: {
@@ -5497,8 +5665,8 @@ export class TrainSchedulingService {
    * Re-derive a built train's lifecycle status from its schedules after one of
    * them changes: any DISPATCHED schedule → IN_SERVICE; any DRAFT/SCHEDULED →
    * SCHEDULED; otherwise AVAILABLE. `moveToYardId` relocates the train (arrival
-   * at destination). Manually parked trains (UNDER_MAINTENANCE / OUT_OF_SERVICE)
-   * keep their status — staff own that flag, not the scheduler.
+   * at destination). Manually parked trains (UNDER_MAINTENANCE / OUT_OF_SERVICE
+   * / DEACTIVATED) keep their status — staff own that flag, not the scheduler.
    */
   private async syncBuiltTrainAfterScheduleChange(
     manager: EntityManager,
@@ -6208,11 +6376,21 @@ export class TrainSchedulingService {
    * engine's representative fallbacks for bookings whose cargo/container type
    * has no wagon type configured. Loaded once per request before mapping.
    */
+  /** Wagon types are near-static reference data — a short TTL cache spares one
+   * table scan per detail/board request without letting edits go stale long. */
+  private wagonTareDimsCache: {
+    value: Awaited<ReturnType<TrainSchedulingService['loadWagonTareDims']>>;
+    expiresAt: number;
+  } | null = null;
+
   private async loadWagonTareDims(): Promise<{
     byWagonTypeId: Map<string, { tareWeightTons: number; capacityTons: number }>;
     bulk: { tareWeightTons: number; capacityTons: number };
     container: { tareWeightTons: number; capacityTons: number };
   }> {
+    if (this.wagonTareDimsCache && this.wagonTareDimsCache.expiresAt > Date.now()) {
+      return this.wagonTareDimsCache.value;
+    }
     const types = await this.dataSource.getRepository(WagonType).find();
     const byWagonTypeId = new Map(
       types.map((t) => [
@@ -6223,7 +6401,7 @@ export class TrainSchedulingService {
         },
       ]),
     );
-    return {
+    const value = {
       byWagonTypeId,
       bulk: {
         tareWeightTons: DEFAULT_BULK_WAGON_TARE_TONS,
@@ -6234,6 +6412,8 @@ export class TrainSchedulingService {
         capacityTons: DEFAULT_CONTAINER_WAGON_CAPACITY_TONS,
       },
     };
+    this.wagonTareDimsCache = { value, expiresAt: Date.now() + 60_000 };
+    return value;
   }
 
   /**
@@ -6290,49 +6470,14 @@ export class TrainSchedulingService {
     );
     const allocationIds = allocations.map((a) => a.id);
     const allocatedBookingIds = new Set(allocations.map((a) => a.bookingId));
-    // Booking weights are reported GROSS (cargo + wagon tare) — the number the
-    // locomotive actually hauls and the axis its pull limit is compared against.
-    const tareDims = await this.loadWagonTareDims();
 
     // Import-from-Djibouti trains can only dispatch once loading is confirmed
     // (loadedOnTrainAt on the operation). Other directions have no departure
     // loading gate, so the workspace shows the confirm button as already done.
     const requiresLoadingConfirmation = this.isImportDjiboutiSchedule(schedule);
-    let loadingConfirmed = !requiresLoadingConfirmation;
-    if (requiresLoadingConfirmation) {
-      const op = await this.dataSource
-        .getRepository(ImportDjiboutiOperation)
-        .findOne({ where: { trainScheduleId: schedule.id } });
-      loadingConfirmed = Boolean(op?.loadedOnTrainAt);
-    }
-
-    const windowCfg = await this.getWindowConfig();
-
-    const [containerItems, bulkLoads] = await Promise.all([
-      allocationIds.length
-        ? this.wagonAllocationContainerItemsRepository.findAll({
-            where: { wagonBookingAllocationId: In(allocationIds) },
-            relations: { containerType: true, bookingContainer: true },
-          })
-        : [],
-      allocationIds.length
-        ? this.wagonAllocationBulkLoadsRepository.findAll({
-            where: { wagonBookingAllocationId: In(allocationIds) },
-            relations: { cargoType: true },
-          })
-        : [],
-    ]);
-
-    const containerItemsByAllocation = new Map<string, typeof containerItems>();
-    for (const item of containerItems) {
-      const list = containerItemsByAllocation.get(item.wagonBookingAllocationId) ?? [];
-      list.push(item);
-      containerItemsByAllocation.set(item.wagonBookingAllocationId, list);
-    }
-    const bulkLoadsByAllocation = new Map(
-      bulkLoads.map((load) => [load.wagonBookingAllocationId, load]),
-    );
 
+    // Snapshot state decides below whether the live consist may be drawn at
+    // all, so it is derived before the consist wagons are fetched.
     // Once a schedule leaves DRAFT/SCHEDULED, its physical wagons are released
     // and re-pinned onto later trains — the live wagon↔slot joins no longer
     // describe THIS train. If a frozen snapshot was captured at the transition,
@@ -6347,6 +6492,55 @@ export class TrainSchedulingService {
       (snapshot?.slots ?? []).map((slot) => [slot.trainSetWagonId, slot]),
     );
 
+    // All independent lookups fired at once — they used to run one after
+    // another, stacking round-trips onto every detail request.
+    // tareDims: booking weights are reported GROSS (cargo + wagon tare) — the
+    // number the locomotive actually hauls against its pull limit.
+    const [tareDims, importOp, windowCfg, containerItems, bulkLoads, rawConsistWagons] =
+      await Promise.all([
+        this.loadWagonTareDims(),
+        requiresLoadingConfirmation
+          ? this.dataSource
+              .getRepository(ImportDjiboutiOperation)
+              .findOne({ where: { trainScheduleId: schedule.id } })
+          : null,
+        this.getWindowConfig(),
+        allocationIds.length
+          ? this.wagonAllocationContainerItemsRepository.findAll({
+              where: { wagonBookingAllocationId: In(allocationIds) },
+              relations: { containerType: true, bookingContainer: true },
+            })
+          : [],
+        allocationIds.length
+          ? this.wagonAllocationBulkLoadsRepository.findAll({
+              where: { wagonBookingAllocationId: In(allocationIds) },
+              relations: { cargoType: true },
+            })
+          : [],
+        schedule.trainSet?.trainId && !isWagonAllocationFrozen
+          ? this.dataSource.getRepository(Wagon).find({
+              where: { trainId: schedule.trainSet.trainId },
+              relations: { wagonType: true },
+              // Mirror the pinning direction: a reverse-order schedule draws the
+              // whole consist back-to-front, empties included.
+              order: { sequenceNumber: schedule.reverseWagonOrder ? 'DESC' : 'ASC' },
+            })
+          : [],
+      ]);
+    const loadingConfirmed = requiresLoadingConfirmation
+      ? Boolean(importOp?.loadedOnTrainAt)
+      : true;
+
+    const containerItemsByAllocation = new Map<string, typeof containerItems>();
+    for (const item of containerItems) {
+      const list = containerItemsByAllocation.get(item.wagonBookingAllocationId) ?? [];
+      list.push(item);
+      containerItemsByAllocation.set(item.wagonBookingAllocationId, list);
+    }
+    const bulkLoadsByAllocation = new Map(
+      bulkLoads.map((load) => [load.wagonBookingAllocationId, load]),
+    );
+
     // The trainSet slots below are the PLANNED wagons (one per allocation). A
     // schedule tied to a built train hauls EVERY coupled wagon — empty ones
     // included (the pull-limit check already counts their tare) — so append the
@@ -6369,41 +6563,32 @@ export class TrainSchedulingService {
       0,
       ...(schedule.trainSet?.wagons ?? []).map((w) => w.sequenceNo),
     );
-    const emptyConsistWagons =
-      schedule.trainSet?.trainId && !isWagonAllocationFrozen
-        ? (
-            await this.dataSource.getRepository(Wagon).find({
-              where: { trainId: schedule.trainSet.trainId },
-              relations: { wagonType: true },
-              order: { sequenceNumber: 'ASC' },
-            })
-          )
-            .filter((wagon) => !coveredPhysicalIds.has(wagon.id))
-            .map((wagon, index) => ({
-              // Physical wagon id — there is no TrainSetWagon slot behind this
-              // row, so remove/edit affordances must stay disabled (consistOnly).
-              id: wagon.id,
-              sequenceNo: maxSlotSequenceNo + index + 1,
-              capacityTons: roundTons(Number(wagon.wagonType?.capacityTons ?? 0)),
-              lengthMeters: roundTons(Number(wagon.wagonType?.lengthMeters ?? 0)),
-              assignedWeightTons: 0,
-              tareWeightTons: wagon.wagonType
-                ? roundTons(Number(wagon.wagonType.tareWeightTons))
-                : null,
-              status: 'EMPTY',
-              physicalWagonId: wagon.id,
-              physicalWagonNumber: wagon.wagonNumber ?? null,
-              wagonType: wagon.wagonType
-                ? {
-                    id: wagon.wagonType.id,
-                    code: wagon.wagonType.code,
-                    name: wagon.wagonType.name,
-                  }
-                : null,
-              allocations: [],
-              consistOnly: true,
-            }))
-        : [];
+    const emptyConsistWagons = rawConsistWagons
+      .filter((wagon) => !coveredPhysicalIds.has(wagon.id))
+      .map((wagon, index) => ({
+        // Physical wagon id — there is no TrainSetWagon slot behind this
+        // row, so remove/edit affordances must stay disabled (consistOnly).
+        id: wagon.id,
+        sequenceNo: maxSlotSequenceNo + index + 1,
+        capacityTons: roundTons(Number(wagon.wagonType?.capacityTons ?? 0)),
+        lengthMeters: roundTons(Number(wagon.wagonType?.lengthMeters ?? 0)),
+        assignedWeightTons: 0,
+        tareWeightTons: wagon.wagonType
+          ? roundTons(Number(wagon.wagonType.tareWeightTons))
+          : null,
+        status: 'EMPTY',
+        physicalWagonId: wagon.id,
+        physicalWagonNumber: wagon.wagonNumber ?? null,
+        wagonType: wagon.wagonType
+          ? {
+              id: wagon.wagonType.id,
+              code: wagon.wagonType.code,
+              name: wagon.wagonType.name,
+            }
+          : null,
+        allocations: [],
+        consistOnly: true,
+      }));
 
     return {
       id: schedule.id,
@@ -6413,6 +6598,7 @@ export class TrainSchedulingService {
       trainNumber: schedule.trainNumber ?? null,
       maxWagons: schedule.maxWagons ?? null,
       direction: schedule.direction ?? null,
+      reverseWagonOrder: schedule.reverseWagonOrder ?? false,
       requiresLoadingConfirmation,
       loadingConfirmed,
       // Booking-window phase + phase deadlines drive the countdown timers in the
@@ -6713,8 +6899,13 @@ export class TrainSchedulingService {
   /** Preview wagon allocation issues per linked booking without mutating the schedule. */
   async previewAllocationForSchedule(
     scheduleId: string,
+    // Callers that already hold the full schedule graph (batch board detail)
+    // pass it in so the preview doesn't re-load the same heavy graph.
+    preloadedSchedule?: TrainSchedule,
   ): Promise<WagonAllocationAttemptResult> {
-    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
+    const schedule =
+      preloadedSchedule ??
+      (await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId));
     if (!schedule) {
       throw new NotFoundException(`Train schedule ${scheduleId} not found`);
     }
@@ -6761,7 +6952,10 @@ export class TrainSchedulingService {
     );
     if (!eligible.length) return empty;
 
-    const wagonAssignedIds = await this.getWagonAssignedBookingIds(schedule.id);
+    const wagonAssignedIds = await this.getWagonAssignedBookingIds(
+      schedule.id,
+      schedule,
+    );
     const previewDto = {
       bookingIds: eligible.map((b) => b.id),
       scheduleDate: schedule.scheduledDepartureDate.toISOString(),
@@ -7036,6 +7230,15 @@ export class TrainSchedulingService {
       shortfall: 0,
     }));
 
+    // Gross weight needs the scheduling graph (containers, cargo type, wagon
+    // types) that the trimmed select above deliberately skips.
+    const tareDims = await this.loadWagonTareDims();
+    const fullById = new Map(
+      (await this.bookingsRepository.findByIdsForScheduling(unassigned.map((b) => b.id))).map(
+        (b) => [b.id, b],
+      ),
+    );
+
     const bookings = await Promise.all(
       unassigned.map(async (b) => {
         const assignability = await this.previewUnassignedBookingAssignability(
@@ -7050,6 +7253,11 @@ export class TrainSchedulingService {
           freightType: b.freightType ?? null,
           priorityScore: b.priorityScore ?? 0,
           cargoTotalWeightVgm: Number(b.cargoTotalWeightVgm ?? 0),
+          // GROSS: cargo + tare of the wagons the booking occupies.
+          grossWeightTons: this.grossBookingWeightTons(
+            (fullById.get(b.id) ?? b) as Booking,
+            tareDims,
+          ),
           status: b.status ?? null,
           schedulingStatus: b.schedulingStatus ?? null,
           ...assignability,
@@ -7278,8 +7486,15 @@ export class TrainSchedulingService {
     return this.trainCompositionRemovalLogRepository.findByScheduleId(scheduleId);
   }
 
-  private async getWagonAssignedBookingIds(scheduleId: string): Promise<Set<string>> {
-    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
+  private async getWagonAssignedBookingIds(
+    scheduleId: string,
+    // Pass when the caller already holds the schedule with trainSet.wagons —
+    // only wagon ids are read here, the old full-graph reload was pure waste.
+    preloadedSchedule?: TrainSchedule,
+  ): Promise<Set<string>> {
+    const schedule =
+      preloadedSchedule ??
+      (await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId));
     const wagonIds = (schedule?.trainSet?.wagons ?? []).map((w) => w.id);
     if (!wagonIds.length) return new Set();
 
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 9b7454f36..babf11ef1 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
@@ -44,6 +44,15 @@ export class TrainBuilderController {
     return this.trainBuilderService.listBuilt(query);
   }
 
+  // Must be declared before @Get(':id') so the path isn't captured as an id.
+  @Get('used-train-numbers')
+  @ApiOperation({
+    summary: 'Import/export run numbers already claimed by existing trains',
+  })
+  usedTrainNumbers() {
+    return this.trainBuilderService.usedTrainNumbers();
+  }
+
   @Get(':id')
   @ApiOperation({ summary: 'Full train composition: locomotives, ordered wagons, totals vs. limits' })
   composition(@Param('id', ParseUUIDPipe) id: string) {
@@ -115,6 +124,22 @@ export class TrainBuilderController {
     return this.trainBuilderService.reorderWagons(id, dto);
   }
 
+  @Post(':id/deactivate')
+  @FleetManage()
+  @ApiOperation({
+    summary: 'Deactivate the train (park it) — only allowed with no active schedule',
+  })
+  deactivate(@Param('id', ParseUUIDPipe) id: string) {
+    return this.trainBuilderService.deactivate(id);
+  }
+
+  @Post(':id/activate')
+  @FleetManage()
+  @ApiOperation({ summary: 'Reactivate a deactivated train back to AVAILABLE' })
+  activate(@Param('id', ParseUUIDPipe) id: string) {
+    return this.trainBuilderService.activate(id);
+  }
+
   @Delete(':id')
   @FleetManage()
   @HttpCode(HttpStatus.NO_CONTENT)
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 10b400993..3658f4f37 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
@@ -153,6 +153,38 @@ export class TrainBuilderService {
     };
   }
 
+  /**
+   * Run numbers already claimed by live (non-deleted) trains, split by
+   * direction. Legacy single `train_number` values are sorted into a side by
+   * parity (even = import, odd = export) so the pickers can grey them out too.
+   */
+  async usedTrainNumbers() {
+    const rows: {
+      import_train_number: string | null;
+      export_train_number: string | null;
+      train_number: string | null;
+    }[] = await this.dataSource.query(
+      `SELECT import_train_number, export_train_number, train_number
+         FROM freight.trains
+        WHERE deleted_at IS NULL`,
+    );
+
+    const importTrainNumbers = new Set<string>();
+    const exportTrainNumbers = new Set<string>();
+    for (const row of rows) {
+      if (row.import_train_number) importTrainNumbers.add(row.import_train_number);
+      if (row.export_train_number) exportTrainNumbers.add(row.export_train_number);
+      const legacy = row.train_number?.trim();
+      if (legacy && /^\d+$/.test(legacy)) {
+        (Number(legacy) % 2 === 0 ? importTrainNumbers : exportTrainNumbers).add(legacy);
+      }
+    }
+    return {
+      importTrainNumbers: [...importTrainNumbers].sort(),
+      exportTrainNumbers: [...exportTrainNumbers].sort(),
+    };
+  }
+
   /**
    * One ACTIVE schedule per train for the page (prefer the DISPATCHED run,
    * else the earliest upcoming departure) — feeds the list's direction tint
@@ -532,6 +564,50 @@ export class TrainBuilderService {
     return this.getComposition(id);
   }
 
+  /**
+   * Park the train indefinitely (status DEACTIVATED). Blocked while it still
+   * has a live (DRAFT/SCHEDULED/DISPATCHED) schedule. The consist stays
+   * coupled; like UNDER_MAINTENANCE / OUT_OF_SERVICE the flag is staff-owned —
+   * the scheduler never overwrites it and refuses the train for new schedules.
+   */
+  async deactivate(id: string) {
+    await this.dataSource.transaction(async (manager) => {
+      const train = await manager.getRepository(Train).findOne({ where: { id } });
+      if (!train) throw new NotFoundException(`Train ${id} not found`);
+      if (train.status === Freight.TrainStatus.Deactivated) return;
+      const active: { count: string }[] = await manager.query(
+        `SELECT COUNT(*)::text AS count
+           FROM freight.train_schedules ts
+           JOIN freight.train_sets tset ON tset.id = ts.train_set_id
+          WHERE tset.train_id = $1
+            AND ts.deleted_at IS NULL
+            AND ts.status IN ('DRAFT', 'SCHEDULED', 'DISPATCHED')`,
+        [id],
+      );
+      if (Number(active[0]?.count ?? 0) > 0) {
+        throw new ConflictException(
+          'Train has active schedules; cancel them before deactivating the train',
+        );
+      }
+      await manager
+        .getRepository(Train)
+        .update(id, { status: Freight.TrainStatus.Deactivated });
+    });
+    return this.getComposition(id);
+  }
+
+  /** Reactivate a DEACTIVATED train back to AVAILABLE so it can be scheduled again. */
+  async activate(id: string) {
+    const train = await this.dataSource.getRepository(Train).findOne({ where: { id } });
+    if (!train) throw new NotFoundException(`Train ${id} not found`);
+    if (train.status === Freight.TrainStatus.Deactivated) {
+      await this.dataSource
+        .getRepository(Train)
+        .update(id, { status: Freight.TrainStatus.Available });
+    }
+    return this.getComposition(id);
+  }
+
   /** Disband the train: release wagons and locomotives, then delete it. */
   async disband(id: string): Promise<void> {
     await this.dataSource.transaction(async (manager) => {
diff --git a/apps/edr-freight-api/src/modules/wagons/train-runs.const.ts b/apps/edr-freight-api/src/modules/wagons/train-runs.const.ts
new file mode 100644
index 000000000..85bb5e88a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/wagons/train-runs.const.ts
@@ -0,0 +1,41 @@
+/**
+ * EDR run-number pairs, keyed by the odd EXPORT run (Ethiopia → Djibouti). The
+ * even IMPORT run (Djibouti → Ethiopia) is fixed by the export run.
+ *
+ * Run numbers are always 4 digits (8401, never 84001). Pairs are listed out
+ * rather than computed from the 8001/+100/+1 pattern, so a run that ever breaks
+ * the convention stays correct here.
+ *
+ * SeedWagonRunNumbers2280000000000 carries its own frozen copy on purpose: a
+ * migration must keep doing what it did when it was applied, whereas this list
+ * is live config for the update script. Add or retire runs HERE.
+ */
+export const TRAIN_RUN_PAIRS: Record<string, string> = {
+  '8001': '8002',
+  '8101': '8102',
+  '8201': '8202',
+  '8301': '8302',
+  '8401': '8402',
+  '8501': '8502',
+  '8601': '8602',
+  '8701': '8702',
+  '8801': '8802',
+  '8901': '8902',
+  '9001': '9002',
+};
+
+/** Even IMPORT run -> its odd EXPORT run. Derived so the two cannot drift. */
+export const EXPORT_BY_IMPORT: Record<string, string> = Object.fromEntries(
+  Object.entries(TRAIN_RUN_PAIRS).map(([exportRun, importRun]) => [importRun, exportRun]),
+);
+
+/**
+ * Normalise any run number to its EXPORT run. Accepts either half of a pair, so
+ * a sheet listing "8002" and one listing "8001" both resolve to the same train.
+ * Returns null when the number belongs to no known run.
+ */
+export const toExportRun = (run: string): string | null => {
+  const value = run.trim();
+  if (TRAIN_RUN_PAIRS[value]) return value;
+  return EXPORT_BY_IMPORT[value] ?? null;
+};
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
index 1549caf0b..1deedd14d 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
@@ -1926,7 +1926,8 @@ export class WarehouseInventoryService {
 
     // 1. Schedule must exist, be ARRIVED, and be an IMPORT route (derived from station countries).
     const [schedule] = await this.dataSource.query(
-      `SELECT ts.id, ts.status, oy.country AS "originCountry", dy.country AS "destinationCountry"
+      `SELECT ts.id, ts.status, ts.destination_station_id AS "destinationStationId",
+              oy.country AS "originCountry", dy.country AS "destinationCountry"
          FROM freight.train_schedules ts
          LEFT JOIN freight.yards oy ON oy.id = ts.origin_station_id
          LEFT JOIN freight.yards dy ON dy.id = ts.destination_station_id
@@ -1957,14 +1958,20 @@ export class WarehouseInventoryService {
       tradeDirection: string | null;
       cargoTypeCode: string | null;
     }[] = await this.dataSource.query(
+      // Only bookings whose destination IS this train's final yard unload into
+      // this (final-destination) warehouse. A mid-corridor import that alighted
+      // at an intermediate yard was already unloaded there by the checkpoint
+      // auto-unload; without this filter it would be mis-located into the final
+      // yard's inventory too.
       `SELECT b.id, b.status, b.cargo_total_weight_vgm AS weight,
               b.freight_type AS "freightType", b.trade_direction AS "tradeDirection",
               cgt.code AS "cargoTypeCode"
          FROM freight.train_schedule_bookings tsb
          JOIN freight.bookings b ON b.id = tsb.booking_id AND b.deleted_at IS NULL
          LEFT JOIN freight.cargo_types cgt ON cgt.id = b.cargo_type_id
-        WHERE tsb.train_schedule_id = $1 AND tsb.deleted_at IS NULL`,
-      [scheduleId],
+        WHERE tsb.train_schedule_id = $1 AND tsb.deleted_at IS NULL
+          AND b.destination_yard_id = $2`,
+      [scheduleId, schedule.destinationStationId],
     );
 
     const requestedLocation = warehouseId ? await this.pickDefaultLocation(warehouseId) : null;
diff --git a/apps/edr-freight-api/src/scripts/update-wagon-runs.ts b/apps/edr-freight-api/src/scripts/update-wagon-runs.ts
new file mode 100644
index 000000000..d24f6245e
--- /dev/null
+++ b/apps/edr-freight-api/src/scripts/update-wagon-runs.ts
@@ -0,0 +1,174 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+
+import { AppDataSource } from '../data-source';
+import { TRAIN_RUN_PAIRS, toExportRun } from '../modules/wagons/train-runs.const';
+
+/**
+ * Update wagon run numbers from a roster file — the tool for making the DB match
+ * the operator's sheet.
+ *
+ *   pnpm seed:wagon-runs <file.csv> [--apply]
+ *
+ * CSV: two columns, header optional. Either half of a run pair is accepted, so
+ * "8001" and "8002" both mean the same train.
+ *
+ *   wagon_number,run
+ *   ER0744,8001
+ *   ER0458,8102
+ *
+ * FULL REPLACEMENT: wagons absent from the file have their runs cleared, so the
+ * DB ends up matching the file exactly rather than accumulating stale rows.
+ *
+ * Dry run by default — it validates and prints what would change. Nothing is
+ * written without `--apply`. Validation is fatal on: an unknown run, a wagon not
+ * in the database, or the same wagon claimed by two runs (a wagon holds one run,
+ * so a double-booking has no correct answer and must be fixed in the sheet).
+ */
+interface Row {
+  line: number;
+  wagonNumber: string;
+  exportRun: string;
+}
+
+function parseCsv(path: string) {
+  const text = readFileSync(path, 'utf8');
+  const rows: Row[] = [];
+  const unknownRuns: string[] = [];
+
+  text.split(/\r?\n/).forEach((raw, i) => {
+    const line = i + 1;
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.startsWith('#')) return;
+
+    const [rawWagon = '', rawRun = ''] = trimmed.split(',').map((c) => c.trim());
+    // Skip a header row without needing it to be declared.
+    if (/wagon/i.test(rawWagon) && /run|train/i.test(rawRun)) return;
+    if (!rawWagon || !rawRun) {
+      throw new Error(`line ${line}: expected "wagon_number,run", got "${trimmed}"`);
+    }
+
+    const exportRun = toExportRun(rawRun);
+    if (!exportRun) {
+      unknownRuns.push(`line ${line}: "${rawRun}" (wagon ${rawWagon})`);
+      return;
+    }
+    rows.push({ line, wagonNumber: rawWagon.toUpperCase(), exportRun });
+  });
+
+  return { rows, unknownRuns };
+}
+
+async function updateWagonRuns() {
+  const [fileArg, ...flags] = process.argv.slice(2);
+  const apply = flags.includes('--apply');
+
+  if (!fileArg) {
+    console.error('usage: pnpm seed:wagon-runs <file.csv> [--apply]');
+    process.exit(2);
+  }
+
+  const path = resolve(process.cwd(), fileArg);
+  const { rows, unknownRuns } = parseCsv(path);
+
+  // A wagon in two runs cannot be represented — surface every instance rather
+  // than silently keeping whichever line happened to come first.
+  const seen = new Map<string, Row>();
+  const doubleBooked: string[] = [];
+  for (const row of rows) {
+    const prior = seen.get(row.wagonNumber);
+    if (prior && prior.exportRun !== row.exportRun) {
+      doubleBooked.push(
+        `${row.wagonNumber}: run ${prior.exportRun} (line ${prior.line}) vs ${row.exportRun} (line ${row.line})`,
+      );
+      continue;
+    }
+    if (!prior) seen.set(row.wagonNumber, row);
+  }
+
+  await AppDataSource.initialize();
+  try {
+    const wagonNumbers = [...seen.keys()];
+    const existing: Array<{ wagon_number: string }> = wagonNumbers.length
+      ? await AppDataSource.query(
+          `SELECT wagon_number FROM freight.wagons
+            WHERE deleted_at IS NULL AND wagon_number = ANY($1::text[]);`,
+          [wagonNumbers],
+        )
+      : [];
+    const known = new Set(existing.map((r) => r.wagon_number));
+    const missing = wagonNumbers.filter((w) => !known.has(w));
+
+    const problems = [
+      ...unknownRuns.map((u) => `unknown run  ${u}`),
+      ...doubleBooked.map((d) => `double-booked  ${d}`),
+      ...missing.map((m) => `not in database  ${m}`),
+    ];
+
+    const perRun = new Map<string, number>();
+    for (const row of seen.values()) {
+      if (known.has(row.wagonNumber)) {
+        perRun.set(row.exportRun, (perRun.get(row.exportRun) ?? 0) + 1);
+      }
+    }
+
+    console.log(`\nFile: ${path}`);
+    console.log(`Rows read: ${rows.length + unknownRuns.length} | assignable: ${known.size}`);
+    console.table(
+      Object.keys(TRAIN_RUN_PAIRS).map((exportRun) => ({
+        export_run: exportRun,
+        import_run: TRAIN_RUN_PAIRS[exportRun],
+        wagons: perRun.get(exportRun) ?? 0,
+      })),
+    );
+
+    if (problems.length) {
+      console.error(`\n${problems.length} problem(s) — nothing was written:`);
+      problems.forEach((p) => console.error(`  ${p}`));
+      console.error('\nFix these in the source sheet, then re-run.');
+      process.exit(1);
+    }
+
+    if (!apply) {
+      console.log('\nDry run — no changes written. Re-run with --apply to write.');
+      return;
+    }
+
+    await AppDataSource.transaction(async (manager) => {
+      // Full replacement: clear first so a wagon dropped from the sheet does not
+      // keep a run it no longer has.
+      await manager.query(`
+        UPDATE freight.wagons
+        SET export_train_number = NULL, import_train_number = NULL
+        WHERE export_train_number IS NOT NULL;
+      `);
+
+      for (const exportRun of new Set([...seen.values()].map((r) => r.exportRun))) {
+        const wagons = [...seen.values()]
+          .filter((r) => r.exportRun === exportRun)
+          .map((r) => r.wagonNumber);
+        await manager.query(
+          `UPDATE freight.wagons
+              SET export_train_number = $1,
+                  import_train_number = $2,
+                  updated_at          = now()
+            WHERE wagon_number = ANY($3::text[]);`,
+          [exportRun, TRAIN_RUN_PAIRS[exportRun], wagons],
+        );
+      }
+    });
+
+    const [totals] = await AppDataSource.query(`
+      SELECT COUNT(*) FILTER (WHERE export_train_number IS NOT NULL)::int AS on_a_run
+      FROM freight.wagons WHERE deleted_at IS NULL;
+    `);
+    console.log(`\nApplied. ${totals.on_a_run} wagons now on a run.`);
+  } finally {
+    await AppDataSource.destroy();
+  }
+}
+
+updateWagonRuns().catch((error) => {
+  console.error('Failed to update wagon runs:', error instanceof Error ? error.message : error);
+  process.exit(1);
+});
diff --git a/apps/edr-freight-api/src/seed/dropdown-settings.seeder.ts b/apps/edr-freight-api/src/seed/dropdown-settings.seeder.ts
index 4df5d9028..f717e73d6 100644
--- a/apps/edr-freight-api/src/seed/dropdown-settings.seeder.ts
+++ b/apps/edr-freight-api/src/seed/dropdown-settings.seeder.ts
@@ -48,6 +48,14 @@ const DEFAULT_DROPDOWN_SETTINGS: DefaultDropdownSetting[] = [
       "Minimum days between today and the vessel departure date on an export Release Order.",
     multiple: false,
   },
+  {
+    code: "import_train_numbers",
+    label: "Import train numbers",
+    description:
+      "Even IMPORT run numbers (Djibouti → Ethiopia) selectable when building a train. The paired export number is derived automatically (import − 1).",
+    multiple: false,
+    meta: { searchable: true, clearable: true },
+  },
 ];
 
 @Injectable()
diff --git a/apps/edr-freight-api/src/seed/indode-facility.seeder.ts b/apps/edr-freight-api/src/seed/indode-facility.seeder.ts
index 4b4ae23f0..763bc6c54 100644
--- a/apps/edr-freight-api/src/seed/indode-facility.seeder.ts
+++ b/apps/edr-freight-api/src/seed/indode-facility.seeder.ts
@@ -13,11 +13,13 @@ const INDODE_FACILITY = {
   facilityType: 'DRY_PORT' as const,
   facilityStatus: 'ACTIVE' as const,
   locationName: 'Indode',
-  country: 'Djibouti',
-  city: 'Djibouti',
-  address: 'Indode, Djibouti',
-  latitude: 11.5447,
-  longitude: 43.145,
+  // Indode is the Gelan Multipurpose Port outside Addis — the yard carries it as
+  // KALITY, country Ethiopia. It was seeded as Djibouti, which is the wrong end
+  // of the line. Coordinates are left unset rather than guessed; fill them in
+  // when the real position is to hand.
+  country: 'Ethiopia',
+  city: 'Addis Ababa',
+  address: 'Indode (Gelan), Addis Ababa, Ethiopia',
   capacity: 50000,
   isActive: true,
   notes: 'Primary dry port for container consolidation and distribution',
@@ -72,20 +74,22 @@ export class IndodeFacilitySeeder {
         const yardRepo = manager.getRepository(WarehouseYard);
         const zoneRepo = manager.getRepository(WarehouseZone);
 
-        // Ensure facility exists
-        const facility = await facilityRepo.findOne({
+        // Ensure facility exists. An existing facility row is not proof the
+        // warehouses under it survived, so reuse it and carry on rather than
+        // returning — otherwise a facility with no warehouses stays that way.
+        const existing = await facilityRepo.findOne({
           where: { code: INDODE_FACILITY.code },
         });
 
-        if (facility) {
-          this.logger.log('Indode facility already exists, skipping seed');
-          return;
+        let savedFacility: Facility;
+        if (existing) {
+          savedFacility = await facilityRepo.save({ ...existing, ...INDODE_FACILITY });
+          this.logger.log(`Facility ${savedFacility.code} already exists, reusing`);
+        } else {
+          savedFacility = await facilityRepo.save(facilityRepo.create(INDODE_FACILITY));
+          this.logger.log(`Created facility: ${savedFacility.code}`);
         }
 
-        const newFacility = facilityRepo.create(INDODE_FACILITY);
-        const savedFacility = await facilityRepo.save(newFacility);
-        this.logger.log(`Created facility: ${savedFacility.code}`);
-
         // Create warehouses for the facility
         for (const warehouseData of WAREHOUSES) {
           try {
diff --git a/apps/edr-freight-api/src/seed/yard-facilities.seeder.ts b/apps/edr-freight-api/src/seed/yard-facilities.seeder.ts
index 47754bd93..1822a877f 100644
--- a/apps/edr-freight-api/src/seed/yard-facilities.seeder.ts
+++ b/apps/edr-freight-api/src/seed/yard-facilities.seeder.ts
@@ -16,12 +16,19 @@ import { DataSource } from 'typeorm';
  * Djibouti and `NEGAD_FY_BCC` in Ethiopia, currently inactive) and it is not yet
  * settled which is the intercity facility.
  */
-const FACILITY_YARDS: Array<{ code: string; facility: string; hasWarehouse: boolean }> = [
-  { code: 'KALITY', facility: 'Indode', hasWarehouse: true },
-  { code: 'LEGACY_DEST', facility: 'Sebeta', hasWarehouse: false },
-  { code: 'MOJO', facility: 'Modjo', hasWarehouse: false },
-  { code: 'ADAMA', facility: 'Adama', hasWarehouse: false },
-  { code: 'DIRE_DAWA', facility: 'Dire Dawa', hasWarehouse: false },
+const FACILITY_YARDS: Array<{
+  code: string;
+  facility: string;
+  hasWarehouse: boolean;
+  handlesContainer: boolean;
+}> = [
+  // Containers need a reach stacker or gantry — only these three are equipped.
+  // Bulk needs far less, so every facility handles it.
+  { code: 'KALITY', facility: 'Indode', hasWarehouse: true, handlesContainer: true },
+  { code: 'MOJO', facility: 'Modjo', hasWarehouse: false, handlesContainer: true },
+  { code: 'DIRE_DAWA', facility: 'Dire Dawa', hasWarehouse: false, handlesContainer: true },
+  { code: 'LEGACY_DEST', facility: 'Sebeta', hasWarehouse: false, handlesContainer: false },
+  { code: 'ADAMA', facility: 'Adama', hasWarehouse: false, handlesContainer: false },
 ];
 
 @Injectable()
@@ -35,7 +42,7 @@ export class YardFacilitiesSeeder {
    * yards — a missing code is logged and skipped rather than invented.
    */
   async run(): Promise<void> {
-    for (const { code, facility, hasWarehouse } of FACILITY_YARDS) {
+    for (const { code, facility, hasWarehouse, handlesContainer } of FACILITY_YARDS) {
       const [yard]: Array<{ id: string }> = await this.dataSource.query(
         `SELECT id FROM freight.yards WHERE code = $1 AND deleted_at IS NULL`,
         [code],
@@ -53,11 +60,15 @@ export class YardFacilitiesSeeder {
       );
 
       await this.dataSource.query(
-        `INSERT INTO freight.yard_facilities (yard_id, has_warehouse, equipment_notes)
-         VALUES ($1, $2, $3)
+        `INSERT INTO freight.yard_facilities
+           (yard_id, has_warehouse, handles_container, handles_bulk, equipment_notes)
+         VALUES ($1, $2, $3, true, $4)
          ON CONFLICT (yard_id) WHERE deleted_at IS NULL
-         DO UPDATE SET has_warehouse = EXCLUDED.has_warehouse, updated_at = NOW()`,
-        [yard.id, hasWarehouse, `${facility} load/unload facility`],
+         DO UPDATE SET has_warehouse     = EXCLUDED.has_warehouse,
+                       handles_container = EXCLUDED.handles_container,
+                       handles_bulk      = EXCLUDED.handles_bulk,
+                       updated_at        = NOW()`,
+        [yard.id, hasWarehouse, handlesContainer, `${facility} load/unload facility`],
       );
     }
     this.logger.log(
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index c82f64ed2..813595690 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -846,6 +846,16 @@ const App = () => {
             </RequirePermission>
           }
         />
+        <Route
+          path="contracts/clearance-documents/:id"
+          element={
+            <RequirePermission
+              permission={FREIGHT_PERMS.contracts.opsClearanceReview}
+            >
+              <ContractClearanceDetailPage />
+            </RequirePermission>
+          }
+        />
         {/* GL (Path B) contract clearance review hub */}
         <Route
           path="contracts/clearance"
diff --git a/apps/edr-freight-web/backoffice/src/auth/http.ts b/apps/edr-freight-web/backoffice/src/auth/http.ts
index e43351015..9fe86ab1e 100644
--- a/apps/edr-freight-web/backoffice/src/auth/http.ts
+++ b/apps/edr-freight-web/backoffice/src/auth/http.ts
@@ -15,10 +15,23 @@ import {
 } from "./cookies";
 import type { AuthTokens } from "./types";
 
+declare module "axios" {
+  export interface AxiosRequestConfig {
+    /**
+     * When true, the response interceptor does NOT raise the global error modal
+     * for this request's failure. For calls the caller handles itself — e.g. a
+     * probe that is expected to 404 before falling back (GL clearance detail
+     * tries /contracts/:id then /bookings/:id). The rejection still propagates.
+     */
+    suppressErrorModal?: boolean;
+  }
+}
+
 type RetriableRequest = {
   _retry?: boolean;
   headers?: Record<string, string>;
   url?: string;
+  suppressErrorModal?: boolean;
 };
 
 const api = axios.create({
@@ -100,8 +113,13 @@ api.interceptors.response.use(
       originalRequest.url?.includes("/auth/refresh-token")
     ) {
       // Surface the server's actual error message in the global error modal
-      // (401s are handled by the session-refresh flow, so skip them).
-      if (error.response && error.response.status !== 401) {
+      // (401s are handled by the session-refresh flow, so skip them). A request
+      // may opt out via `suppressErrorModal` when it handles the failure itself.
+      if (
+        error.response &&
+        error.response.status !== 401 &&
+        !originalRequest?.suppressErrorModal
+      ) {
         const payload = extractApiErrorPayload(error);
         if (payload) emitApiError(payload);
       }
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/ContractReferenceLink.tsx b/apps/edr-freight-web/backoffice/src/components/bookings/ContractReferenceLink.tsx
new file mode 100644
index 000000000..94061eee2
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/ContractReferenceLink.tsx
@@ -0,0 +1,43 @@
+import { Link } from "react-router-dom";
+
+/**
+ * The parent contract's reference, linking to that contract's detail page.
+ *
+ * Backoffice-local on purpose: the contract detail route differs per app
+ * (`/dashboard/contract-requests/:id` here vs `/contracts/:id` in the portal),
+ * so the portal keeps its own copy in `pages/bookings/booking-display.tsx`
+ * rather than the two sharing a component that would have to take the route as
+ * a prop at every call site.
+ *
+ * Renders nothing when either field is missing: `contractId` is nullable on the
+ * booking, and only the bookings list/detail endpoints join `contractReference`
+ * — other endpoints (warehouse, fleet, payments) return booking rows without it,
+ * and a link with no id would be a dead one.
+ *
+ * `stopPropagation` matters: booking rows are click-to-navigate, so without it a
+ * click here would race the row handler and land on the booking instead.
+ */
+export function ContractReferenceLink({
+  contractId,
+  contractReference,
+  className,
+}: {
+  contractId?: string | null;
+  contractReference?: string | null;
+  className?: string;
+}) {
+  if (!contractId || !contractReference) return null;
+
+  return (
+    <Link
+      to={`/dashboard/contract-requests/${contractId}`}
+      onClick={(e) => e.stopPropagation()}
+      className={
+        className ??
+        "block truncate font-mono text-xs text-muted-foreground underline underline-offset-2 hover:text-foreground"
+      }
+    >
+      {contractReference}
+    </Link>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingRequestHero.tsx b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingRequestHero.tsx
index aa14fe8cd..3ee5d72a0 100644
--- a/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingRequestHero.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingRequestHero.tsx
@@ -24,6 +24,7 @@ import type { LucideIcon } from "lucide-react";
 import type { BookingDetail } from "@/types/booking";
 import { BookingStatusBadge } from "@/components/bookings/BookingStatusBadge";
 import { BookingPriorityBadge } from "@/components/bookings/BookingPriorityBadge";
+import { ContractReferenceLink } from "@/components/bookings/ContractReferenceLink";
 import { SchedulingStatusBadge } from "@/components/trainScheduling/ScheduleStatusBadge";
 import { NextStepBanner } from "@/components/bookings/NextStepBanner";
 
@@ -94,9 +95,15 @@ export function BookingRequestHero({
               Booking reference
             </Text>
             <Group gap="sm" align="center" wrap="wrap">
-              <Title order={2} fw={700} style={{ letterSpacing: "-0.4px" }}>
-                {booking.reference}
-              </Title>
+              <Stack gap={2} miw={0}>
+                <Title order={2} fw={700} style={{ letterSpacing: "-0.4px" }}>
+                  {booking.reference}
+                </Title>
+                <ContractReferenceLink
+                  contractId={booking.contractId}
+                  contractReference={booking.contractReference}
+                />
+              </Stack>
               <BookingStatusBadge status={booking.status} />
               <BookingPriorityBadge score={booking.priorityScore} />
               {booking.schedulingStatus ? (
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 5633745aa..97199afc3 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -4,6 +4,7 @@ import {
   useRef,
   useState,
   type KeyboardEvent,
+  type ReactNode,
 } from "react";
 import { useNavigate, useParams, useSearchParams } from "react-router-dom";
 import { useMutation, useQuery } from "@tanstack/react-query";
@@ -37,10 +38,12 @@ import {
   FileDown,
   FileText,
   FileUp,
+  Flame,
   MapPin,
   Package,
   Receipt,
   Repeat,
+  Snowflake,
   X,
 } from "lucide-react";
 import type { Freight } from "@edr/types";
@@ -128,6 +131,10 @@ interface UnitDraft {
   containerNumber: string;
   sealNumber: string;
   vgmTons: string;
+  /** Handling is per physical container; the line counts roll these up. */
+  isHazardous: boolean;
+  isReefer: boolean;
+  isReturn: boolean;
 }
 
 /** Mirrors the portal shipment form's container line: line-level quantity +
@@ -150,7 +157,14 @@ interface BulkDraft {
 }
 
 function emptyUnit(): UnitDraft {
-  return { containerNumber: "", sealNumber: "", vgmTons: "" };
+  return {
+    containerNumber: "",
+    sealNumber: "",
+    vgmTons: "",
+    isHazardous: false,
+    isReefer: false,
+    isReturn: false,
+  };
 }
 
 function emptyLine(size: string): ContainerLineDraft {
@@ -285,6 +299,41 @@ export default function GlCreateBookingForm() {
   // Legacy contracts (no equipment return chosen at creation) keep the old
   // booking-level toggle.
   const legacyReturnToggle = isContainer && !contract?.equipmentReturn;
+  /**
+   * Handling switches offered on each container row — only the services this
+   * contract was created with, since the server rejects the others.
+   */
+  const handlingColumns = (
+    [
+      contract?.isHazardous && {
+        key: "isHazardous",
+        label: "Hazardous",
+        icon: <Flame size={14} />,
+        color: "#C0392B",
+      },
+      contract?.isReefer && {
+        key: "isReefer",
+        label: "Refrigerated",
+        icon: <Snowflake size={14} />,
+        color: "#2E5B96",
+      },
+      contractWithReturn && {
+        key: "isReturn",
+        label: "With return",
+        icon: <Repeat size={14} />,
+        color: "#0A6F4D",
+      },
+    ] as Array<
+      | false
+      | undefined
+      | { key: keyof UnitDraft; label: string; icon: ReactNode; color: string }
+    >
+  ).filter(Boolean) as Array<{
+    key: "isHazardous" | "isReefer" | "isReturn";
+    label: string;
+    icon: ReactNode;
+    color: string;
+  }>;
   // Intercity shipments ride a passing import/export train staff pick at
   // finalize time — no shipment day is chosen and no window gate applies.
   const isIntercity = contract?.tradeDirection === "DOMESTIC";
@@ -358,6 +407,9 @@ export default function GlCreateBookingForm() {
 
   useEffect(() => {
     if (!bookingRequest || prefilled) return;
+    // A rebook (?copyFrom=) seeds from the expired booking's real cargo —
+    // richer than the request's bare quantities. Let that seed win the race.
+    if (copyFromParam) return;
     setPrefilled(true);
     const lines = bookingRequest.requestedLines ?? {};
     if (lines.containers?.length) {
@@ -399,13 +451,27 @@ export default function GlCreateBookingForm() {
     setContainerLines(
       lines.map((c) => {
         const qty = Math.max(1, c.quantity);
+        // Carry the persisted per-unit details (numbers, seals, VGM, handling)
+        // when the source booking has them — a rebooked EXPIRED booking does,
+        // and its cargo is fixed server-side anyway.
+        const units: UnitDraft[] =
+          c.units?.length === qty
+            ? c.units.map((u) => ({
+                containerNumber: u.containerNumber ?? "",
+                sealNumber: u.sealNumber ?? "",
+                vgmTons: u.vgmTons != null ? String(u.vgmTons) : "",
+                isHazardous: Boolean(u.isHazardous),
+                isReefer: Boolean(u.isReefer),
+                isReturn: Boolean(u.isReturn),
+              }))
+            : Array.from({ length: qty }, emptyUnit);
         return {
           containerSize: String(c.containerType?.sizeFt ?? ""),
           quantity: String(qty),
-          hazardousQuantity: "0",
-          reeferQuantity: "0",
-          returnQuantity: "0",
-          units: Array.from({ length: qty }, emptyUnit),
+          hazardousQuantity: String(units.filter((u) => u.isHazardous).length),
+          reeferQuantity: String(units.filter((u) => u.isReefer).length),
+          returnQuantity: String(units.filter((u) => u.isReturn).length),
+          units,
         };
       }),
     );
@@ -488,6 +554,18 @@ export default function GlCreateBookingForm() {
     enabled: cargoQuery !== null && !isIntercity,
   });
 
+  /**
+   * Line handling totals are a roll-up of the per-container switches — the
+   * count is however many containers ticked each service. Recomputed on every
+   * unit change so the price estimate and payload follow the switches.
+   */
+  const withDerivedCounts = (line: ContainerLineDraft): ContainerLineDraft => ({
+    ...line,
+    hazardousQuantity: String(line.units.filter((u) => u.isHazardous).length),
+    reeferQuantity: String(line.units.filter((u) => u.isReefer).length),
+    returnQuantity: String(line.units.filter((u) => u.isReturn).length),
+  });
+
   // Keep the units array length in sync with the entered quantity.
   const syncUnits = (lineIdx: number, qty: number) => {
     setContainerLines((prev) =>
@@ -496,7 +574,7 @@ export default function GlCreateBookingForm() {
         const next = [...line.units];
         while (next.length < qty) next.push(emptyUnit());
         next.length = Math.max(0, qty);
-        return { ...line, units: next };
+        return withDerivedCounts({ ...line, units: next });
       }),
     );
   };
@@ -511,11 +589,16 @@ export default function GlCreateBookingForm() {
     unitIdx: number,
     patch: Partial<UnitDraft>,
   ) =>
-    patchLine(lineIdx, {
-      units: containerLines[lineIdx].units.map((u, i) =>
-        i === unitIdx ? { ...u, ...patch } : u,
+    setContainerLines((prev) =>
+      prev.map((l, i) =>
+        i === lineIdx
+          ? withDerivedCounts({
+              ...l,
+              units: l.units.map((u, j) => (j === unitIdx ? { ...u, ...patch } : u)),
+            })
+          : l,
       ),
-    });
+    );
 
   // Same client-side validation as the customer portal shipment form
   // (new-shipment-form/schema.ts): ISO container numbers unique within the
@@ -560,10 +643,15 @@ export default function GlCreateBookingForm() {
           hazardousQuantity: String(imported.filter((r) => r.hazardous).length),
           reeferQuantity: String(imported.filter((r) => r.reefer).length),
           returnQuantity: String(imported.filter((r) => r.withReturn).length),
+          // The spreadsheet marks handling per row — carry it onto the
+          // container it belongs to rather than collapsing it to a line count.
           units: imported.map((r) => ({
             containerNumber: r.containerNumber,
             sealNumber: r.sealNumber,
             vgmTons: String(r.vgmTons),
+            isHazardous: Boolean(r.hazardous),
+            isReefer: Boolean(r.reefer),
+            isReturn: Boolean(r.withReturn),
           })),
         };
       }),
@@ -742,6 +830,11 @@ export default function GlCreateBookingForm() {
             containerNumber: u.containerNumber.trim().toUpperCase(),
             ...(u.sealNumber ? { sealNumber: u.sealNumber } : {}),
             vgmTons: Number(u.vgmTons) || 0,
+            // Per-container handling — the server rolls these into the line
+            // counts and bills each surcharge on the ticked containers only.
+            isHazardous: Boolean(u.isHazardous),
+            isReefer: Boolean(u.isReefer),
+            ...(contractWithReturn ? { isReturn: Boolean(u.isReturn) } : {}),
           })),
         }));
     } else {
@@ -1175,78 +1268,60 @@ export default function GlCreateBookingForm() {
                         radius={10}
                         styles={fieldStyles}
                       />
-                      {contract.isHazardous && (
-                        <TextInput
-                          type="number"
-                          onKeyDown={blockNegative}
-                          label="Hazardous qty"
-                          min={0}
-                          value={line.hazardousQuantity}
-                          error={
-                            showErrors
-                              ? lineErrors[lineIdx]?.hazardousQuantity
-                              : undefined
-                          }
-                          onChange={(e) =>
-                            patchLine(lineIdx, {
-                              hazardousQuantity: e.currentTarget.value,
-                            })
-                          }
-                          radius={10}
-                          styles={fieldStyles}
-                        />
-                      )}
-                      {contract.isReefer && (
-                        <TextInput
-                          type="number"
-                          onKeyDown={blockNegative}
-                          label="Reefer qty"
-                          min={0}
-                          value={line.reeferQuantity}
-                          error={
-                            showErrors
-                              ? lineErrors[lineIdx]?.reeferQuantity
-                              : undefined
-                          }
-                          onChange={(e) =>
-                            patchLine(lineIdx, {
-                              reeferQuantity: e.currentTarget.value,
-                            })
-                          }
-                          radius={10}
-                          styles={fieldStyles}
-                        />
-                      )}
-                      {contractWithReturn && (
-                        <TextInput
-                          type="number"
-                          onKeyDown={blockNegative}
-                          label="With return qty"
-                          description="Containers EDR returns empty"
-                          min={0}
-                          value={line.returnQuantity}
-                          error={
-                            showErrors
-                              ? lineErrors[lineIdx]?.returnQuantity
-                              : undefined
-                          }
-                          onChange={(e) =>
-                            patchLine(lineIdx, {
-                              returnQuantity: e.currentTarget.value,
-                            })
-                          }
-                          radius={10}
-                          styles={fieldStyles}
-                        />
-                      )}
                     </Group>
 
                     <StepLabel>Per-container details</StepLabel>
+                    {handlingColumns.length > 0 ? (
+                      <Text fz={11} c="dimmed" mt={4}>
+                        Tick the services each individual container needs —
+                        charges apply only to the containers ticked
+                        {handlingColumns
+                          .map((col) => {
+                            const count = line.units.filter(
+                              (u) => u[col.key],
+                            ).length;
+                            return count > 0 ? ` · ${count} ${col.label.toLowerCase()}` : "";
+                          })
+                          .join("")}
+                        .
+                      </Text>
+                    ) : null}
                     <Stack gap={10} mt={8}>
+                      {/* Header row — input labels + handling-service labels,
+                          one aligned grid shared by every unit row below.
+                          Same layout as the portal shipment form. */}
+                      {line.units.length > 0 && (
+                        <Group gap={10} wrap="nowrap" align="flex-end">
+                          <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
+                            Container number *
+                          </Text>
+                          <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
+                            Seal number
+                          </Text>
+                          <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
+                            VGM (tons) *
+                          </Text>
+                          {handlingColumns.map((col) => (
+                            <Group
+                              key={col.key}
+                              gap={4}
+                              wrap="nowrap"
+                              justify="center"
+                              style={{ width: 96, flexShrink: 0 }}
+                            >
+                              <span style={{ color: col.color, display: "flex" }}>
+                                {col.icon}
+                              </span>
+                              <Text fz={12} fw={600} c="#10202F">
+                                {col.label}
+                              </Text>
+                            </Group>
+                          ))}
+                        </Group>
+                      )}
                       {line.units.map((unit, unitIdx) => (
-                        <Group key={unitIdx} gap={10} grow align="flex-start">
+                        <Group key={unitIdx} gap={10} wrap="nowrap" align="flex-start">
                           <TextInput
-                            label={unitIdx === 0 ? "Container number *" : undefined}
                             placeholder="e.g. MSCU1234567"
                             value={unit.containerNumber}
                             error={
@@ -1262,9 +1337,9 @@ export default function GlCreateBookingForm() {
                             }
                             radius={10}
                             styles={fieldStyles}
+                            style={{ flex: 1 }}
                           />
                           <TextInput
-                            label={unitIdx === 0 ? "Seal number" : undefined}
                             placeholder="Optional"
                             value={unit.sealNumber}
                             onChange={(e) =>
@@ -1274,11 +1349,11 @@ export default function GlCreateBookingForm() {
                             }
                             radius={10}
                             styles={fieldStyles}
+                            style={{ flex: 1 }}
                           />
                           <TextInput
                             type="number"
                             onKeyDown={blockNegative}
-                            label={unitIdx === 0 ? "VGM (tons) *" : undefined}
                             placeholder="e.g. 24.5"
                             min={0}
                             step={0.01}
@@ -1295,7 +1370,32 @@ export default function GlCreateBookingForm() {
                             }
                             radius={10}
                             styles={fieldStyles}
+                            style={{ flex: 1 }}
                           />
+                          {handlingColumns.map((col) => (
+                            <Box
+                              key={col.key}
+                              style={{
+                                width: 96,
+                                flexShrink: 0,
+                                height: 42,
+                                display: "flex",
+                                alignItems: "center",
+                                justifyContent: "center",
+                              }}
+                            >
+                              <Switch
+                                checked={Boolean(unit[col.key])}
+                                aria-label={`${col.label} — container ${unitIdx + 1}`}
+                                onChange={(e) =>
+                                  patchUnit(lineIdx, unitIdx, {
+                                    [col.key]: e.currentTarget.checked,
+                                  })
+                                }
+                                size="sm"
+                              />
+                            </Box>
+                          ))}
                         </Group>
                       ))}
                     </Stack>
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 699706654..9d5dfe65e 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/PhasedClearanceActionPanel.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from "react";
+import { useEffect, useMemo, useState } from "react";
 import {
   Alert,
   Badge,
@@ -72,6 +72,7 @@ export type ClearanceViewLike = Pick<
   | "linkedBookingId"
   | "riskLevel"
   | "riskAssignedAt"
+  | "riskHistory"
   | "secondDuty"
   | "importReleaseGranted"
 > & { operationReady?: boolean };
@@ -1040,11 +1041,28 @@ function RiskStep({
   done: boolean;
   onChanged?: () => void;
 }) {
-  const [level, setLevel] = useState<string>("GREEN");
+  const assigned = done || Boolean(clearance.riskLevel);
+  // Duty is advised off the risk level, so once that is done the decision is
+  // final. Until then a mis-assigned level must stay correctable — the server
+  // overwrites the milestone metadata on reassignment. Mirrors AssignRiskCard.
+  const locked = isMilestoneDone(clearance.milestones, "DUTY_TAXES_ADVISED");
+
+  const [level, setLevel] = useState<string>(clearance.riskLevel ?? "GREEN");
   const [loading, setLoading] = useState(false);
 
-  if (done || clearance.riskLevel) {
-    return (
+  // The clearance view loads (and refetches after a reassignment) after first
+  // render, so mirror the persisted level onto the control whenever it changes —
+  // otherwise reopening the step offers GREEN whatever is actually assigned.
+  useEffect(() => {
+    if (clearance.riskLevel) setLevel(clearance.riskLevel);
+  }, [clearance.riskLevel]);
+
+  // Only the decisions before the current one — the badge above already states
+  // the level in force, so repeating it as a trail entry reads as a duplicate.
+  const priorDecisions = (clearance.riskHistory ?? []).slice(0, -1);
+
+  const assignedSummary = assigned ? (
+    <Stack gap={6}>
       <Group gap="sm">
         <Badge
           color={RISK_LEVEL_COLOR[clearance.riskLevel ?? ""] ?? "gray"}
@@ -1061,12 +1079,35 @@ function RiskStep({
           . The customer can see this level.
         </Text>
       </Group>
-    );
+      {priorDecisions.length > 0 ? (
+        <Stack gap={2} pl="xs">
+          <Text size="xs" c="dimmed" fw={600}>
+            Previously
+          </Text>
+          {priorDecisions.map((entry, index) => (
+            <Text key={`${entry.assignedAt}-${index}`} size="xs" c="dimmed">
+              {entry.level}
+              {" · "}
+              {new Date(entry.assignedAt).toLocaleString()}
+              {entry.assignedBy ? ` · ${entry.assignedBy}` : ""}
+              {entry.note ? ` · ${entry.note}` : ""}
+            </Text>
+          ))}
+        </Stack>
+      ) : null}
+    </Stack>
+  ) : null;
+
+  // Assigned and final: the badge is all that is left to show.
+  if (assigned && (locked || !canAct || !bookingId)) {
+    return assignedSummary;
   }
 
   // Customs cannot rate cargo still under transit — the server rejects the
-  // assignment until the T1 is closed, so do not offer the control yet.
-  if (!clearance.t1?.closed) {
+  // assignment until the T1 is closed, so do not offer the control yet. Skipped
+  // once a level exists: risk cannot have been assigned without a closed T1, so
+  // a still-open T1 here is stale data and must not hide the assigned badge.
+  if (!assigned && !clearance.t1?.closed) {
     return (
       <StepStatus
         done={false}
@@ -1088,6 +1129,7 @@ function RiskStep({
 
   return (
     <Stack gap="sm">
+      {assignedSummary}
       <SegmentedControl
         fullWidth
         value={level}
@@ -1100,19 +1142,24 @@ function RiskStep({
       />
       <Group justify="space-between">
         <Text size="xs" c="dimmed">
-          The customer sees the assigned risk level.
+          {assigned
+            ? "Correctable until duty is advised. The customer sees the assigned risk level."
+            : "The customer sees the assigned risk level."}
         </Text>
         <Button
           size="compact-sm"
           color="edr-green"
           loading={loading}
+          disabled={assigned && level === clearance.riskLevel}
           onClick={async () => {
             setLoading(true);
             try {
               await contractsService.assignRisk(bookingId, {
                 riskLevel: level as Freight.CustomsRiskLevel,
               });
-              toast.success("Customs risk assigned");
+              toast.success(
+                assigned ? "Customs risk reassigned" : "Customs risk assigned",
+              );
               onChanged?.();
             } catch (e) {
               toast.error(e instanceof Error ? e.message : "Failed");
@@ -1121,7 +1168,7 @@ function RiskStep({
             }
           }}
         >
-          Assign risk
+          {assigned ? "Reassign risk" : "Assign risk"}
         </Button>
       </Group>
     </Stack>
diff --git a/apps/edr-freight-web/backoffice/src/components/errors/ApiErrorModal.tsx b/apps/edr-freight-web/backoffice/src/components/errors/ApiErrorModal.tsx
index fb780261a..07c9a39d1 100644
--- a/apps/edr-freight-web/backoffice/src/components/errors/ApiErrorModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/errors/ApiErrorModal.tsx
@@ -104,6 +104,11 @@ export function ApiErrorModal() {
       onClose={close}
       centered
       radius="md"
+      // Mounted at the app root, so its portal is FIRST in <body> — at the
+      // default z-index (200) any page modal opened later (create schedule,
+      // allocation wizard, …) paints over it and the error hides underneath.
+      // Hoist above every Mantine overlay and the react-hot-toast layer (9999).
+      zIndex={10000}
       title={
         <Group gap="xs">
           <AlertTriangle size={18} color="var(--mantine-color-red-6)" />
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 2cedad1eb..05b4bd546 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/BuildTrainModal.tsx
@@ -16,7 +16,8 @@ import { useEffect, useState } from "react";
 import { api } from "@/services/api";
 import type { TrainComposition } from "@/services/trainBuilder.service";
 import { useToast } from "@/hooks/use-toast";
-import { IMPORT_TRAIN_OPTIONS, exportRunFor } from "@/constants/trainRuns";
+import { useImportTrainNumberOptions } from "@/hooks/useImportTrainNumberOptions";
+import { exportRunFor } from "@/constants/trainRuns";
 
 const parseError = (error: unknown, fallback: string) => {
   if (isAxiosError(error)) {
@@ -42,6 +43,9 @@ export default function BuildTrainModal({ opened, onClose, onBuilt }: BuildTrain
   const [notes, setNotes] = useState("");
 
   const yardsQuery = useQuery(api.routes.yards.queryOptions({ staleTime: 5 * 60_000 }));
+  // Admin-managed run list (dropdown settings); numbers already on a train
+  // come back disabled so they cannot be picked twice.
+  const importNumbers = useImportTrainNumberOptions();
   // Only serviceable locomotives standing in the selected yard can be coupled.
   const locomotivesQuery = useQuery(
     api.locomotives.listFiltered.queryOptions({
@@ -150,12 +154,13 @@ export default function BuildTrainModal({ opened, onClose, onBuilt }: BuildTrain
           <Select
             label="Import train number"
             description="Even — Djibouti → Ethiopia runs"
-            placeholder="e.g. 8002"
-            data={IMPORT_TRAIN_OPTIONS}
+            placeholder={importNumbers.isLoading ? "Loading…" : "e.g. 8002"}
+            data={importNumbers.options}
             value={importTrainNumber || null}
             onChange={(value) => setImportTrainNumber(value ?? "")}
             searchable
             clearable
+            nothingFoundMessage="No free run numbers — add more in Dropdown Settings"
           />
         </Group>
         <Select
diff --git a/apps/edr-freight-web/backoffice/src/components/trainBuilder/EditTrainDetailsModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainBuilder/EditTrainDetailsModal.tsx
index 0a2371138..8eb64d3ef 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/EditTrainDetailsModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/EditTrainDetailsModal.tsx
@@ -1,9 +1,11 @@
-import { Button, Group, Modal, Stack, Text, TextInput } from "@mantine/core";
+import { Button, Group, Modal, Select, Stack, Text, TextInput } from "@mantine/core";
 import { useMutation } from "@tanstack/react-query";
 import { Pencil } from "lucide-react";
 import { useEffect, useState } from "react";
 
+import { exportRunFor } from "@/constants/trainRuns";
 import { useToast } from "@/hooks/use-toast";
+import { useImportTrainNumberOptions } from "@/hooks/useImportTrainNumberOptions";
 import { api } from "@/services/api";
 import type { BuiltTrainSummary } from "@/services/trainBuilder.service";
 
@@ -15,9 +17,11 @@ export interface EditTrainDetailsModalProps {
 
 /**
  * Edit a built train's display identity from the list: its name and its fixed
- * import/export run numbers. Composition (yard, locomotives, wagons) is edited
- * on the detail page. Number collisions come back as a 409 with the owning
- * train's code and surface verbatim.
+ * import/export run numbers. The import number comes from the admin-managed
+ * dropdown setting (numbers on other trains are disabled; this train's own
+ * number stays pickable) and the export number follows it. Composition (yard,
+ * locomotives, wagons) is edited on the detail page. Number collisions come
+ * back as a 409 with the owning train's code and surface verbatim.
  */
 const EditTrainDetailsModal = ({ train, onClose }: EditTrainDetailsModalProps) => {
   const { toast } = useToast();
@@ -25,6 +29,8 @@ const EditTrainDetailsModal = ({ train, onClose }: EditTrainDetailsModalProps) =
   const [importNo, setImportNo] = useState("");
   const [exportNo, setExportNo] = useState("");
 
+  const importNumbers = useImportTrainNumberOptions(train?.importTrainNumber);
+
   useEffect(() => {
     if (train) {
       setName(train.trainName ?? "");
@@ -86,20 +92,29 @@ const EditTrainDetailsModal = ({ train, onClose }: EditTrainDetailsModalProps) =
           radius="md"
         />
         <Group grow>
-          <TextInput
+          <Select
             label="Import train no."
-            placeholder="e.g. 8002"
-            value={importNo}
-            onChange={(e) => setImportNo(e.currentTarget.value)}
-            maxLength={20}
+            placeholder={importNumbers.isLoading ? "Loading…" : "e.g. 8002"}
+            data={importNumbers.options}
+            value={importNo || null}
+            onChange={(value) => {
+              // Clearing keeps the stored numbers (empty inputs are dropped on
+              // save); a pick re-derives the paired export run.
+              setImportNo(value ?? "");
+              setExportNo(value ? exportRunFor(value) : (train?.exportTrainNumber ?? ""));
+            }}
+            searchable
+            clearable
+            nothingFoundMessage="No free run numbers — add more in Dropdown Settings"
             radius="md"
           />
           <TextInput
             label="Export train no."
+            description="Follows the import run"
             placeholder="e.g. 8001"
             value={exportNo}
-            onChange={(e) => setExportNo(e.currentTarget.value)}
-            maxLength={20}
+            readOnly
+            variant="filled"
             radius="md"
           />
         </Group>
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 7cbdfcc52..ef5a661e8 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts
+++ b/apps/edr-freight-web/backoffice/src/components/trainBuilder/trainStatus.ts
@@ -15,6 +15,8 @@ export const trainStatusColor = (status: BuiltTrainStatus | string): string => {
       return "yellow";
     case "OUT_OF_SERVICE":
       return "red";
+    case "DEACTIVATED":
+      return "gray";
     default:
       return "gray";
   }
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWarningsAlert.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWarningsAlert.tsx
index 25bf2480f..d84d4e8be 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWarningsAlert.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWarningsAlert.tsx
@@ -40,17 +40,21 @@ export function PreviewSummary({
   summary?: {
     totalBookings: number;
     totalWeightTons: number;
+    grossWeightTons?: number;
+    totalTareTons?: number;
     wagonType: string;
     wagonsNeeded: number;
     totalLengthMeters: number;
   };
 }) {
   if (!summary) return null;
+  // GROSS — the axis every train limit is spent against.
+  const gross = summary.grossWeightTons ?? summary.totalWeightTons;
   const stats = [
     { label: "Bookings", value: String(summary.totalBookings) },
     { label: "Wagons", value: String(summary.wagonsNeeded) },
     { label: "Wagon type", value: summary.wagonType },
-    { label: "Total weight", value: `${summary.totalWeightTons}T` },
+    { label: "Gross weight", value: `${gross}T` },
     { label: "Train length", value: `${summary.totalLengthMeters}m` },
   ];
   return (
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
index 867a0f895..c7fc49b18 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
@@ -99,9 +99,8 @@ function usedWeight(schedule: TrainScheduleDetail): number {
 /**
  * Pull capacity of the set = the WEAKEST locomotive's max pull weight (0 when
  * unknown). The API caps at the weakest loco, not the sum of all locos — a
- * consist can only pull as hard as its weakest engine. Note: the API also adds
- * the consist tare to the used weight when it checks this cap; tare isn't
- * available client-side, so this meter compares cargo-only load against pull.
+ * consist can only pull as hard as its weakest engine. Both sides of this meter
+ * are gross: `usedWeight` sums per-booking gross (cargo + wagon tare).
  */
 function pullCapacity(schedule: TrainScheduleDetail): number {
   const set = schedule.trainSet;
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/TrainCompositionDiagram.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/TrainCompositionDiagram.tsx
index 2805ba60a..af8917e00 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/TrainCompositionDiagram.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/TrainCompositionDiagram.tsx
@@ -46,6 +46,8 @@ type NormalizedWagon = {
 
 const CAR_WIDTH = 150; // car body + coupler footprint
 
+const round1 = (n: number) => Math.round(n * 10) / 10;
+
 function normalizeWagon(w: DiagramWagonInput, freightType?: string | null): NormalizedWagon {
   const allocations = w.allocations ?? [];
   const firstLoad = (
@@ -268,10 +270,11 @@ const CONTAINER_BORDERS = [
 ];
 
 function WagonCar({ wagon }: { wagon: NormalizedWagon }) {
+  // GROSS on both sides: cargo + tare vs rated payload + tare.
+  const grossTons = round1(wagon.assignedWeightTons + wagon.tareWeightTons);
+  const maxGrossTons = round1(wagon.capacityTons + wagon.tareWeightTons);
   const utilization =
-    wagon.capacityTons > 0
-      ? Math.min(100, Math.round((wagon.assignedWeightTons / wagon.capacityTons) * 100))
-      : 0;
+    maxGrossTons > 0 ? Math.min(100, Math.round((grossTons / maxGrossTons) * 100)) : 0;
   const accent = wagon.isEmpty ? "gray" : wagon.isBulk ? "orange" : "cyan";
   const accentVar = `var(--mantine-color-${accent}-6)`;
 
@@ -281,8 +284,8 @@ function WagonCar({ wagon }: { wagon: NormalizedWagon }) {
         wagon.bookingRefs.length ? wagon.bookingRefs.join(", ") : ""
       }${
         wagon.containerNumbers.length ? `\nContainers: ${wagon.containerNumbers.join(", ")}` : ""
-      }${wagon.cargoDescription ? `\n${wagon.cargoDescription}` : ""}\nLoad: ${wagon.assignedWeightTons}/${wagon.capacityTons}T (${utilization}%)${
-        wagon.tareWeightTons ? `\nTare: ${wagon.tareWeightTons}T` : ""
+      }${wagon.cargoDescription ? `\n${wagon.cargoDescription}` : ""}\nGross: ${grossTons}/${maxGrossTons}T (${utilization}%)\nCargo: ${wagon.assignedWeightTons}T${
+        wagon.tareWeightTons ? ` · Tare: ${wagon.tareWeightTons}T` : ""
       }`;
 
   // container blocks: one per container number (cap visual at 2 = TEU per wagon)
@@ -369,7 +372,7 @@ function WagonCar({ wagon }: { wagon: NormalizedWagon }) {
                   />
                 </Box>
                 <Text size="9px" c="dimmed" ta="center" fw={600}>
-                  {wagon.assignedWeightTons}/{wagon.capacityTons}T
+                  {grossTons}/{maxGrossTons}T
                 </Text>
               </Stack>
             ) : (
@@ -442,7 +445,7 @@ function WagonCar({ wagon }: { wagon: NormalizedWagon }) {
               </Text>
               {!wagon.isEmpty ? (
                 <Text size="8px" c="gray.6" fw={700} style={{ whiteSpace: "nowrap" }}>
-                  {wagon.assignedWeightTons}T
+                  {grossTons}T
                 </Text>
               ) : null}
             </Group>
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/WagonPlanGrid.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/WagonPlanGrid.tsx
index 086f78ddc..e5b63ea24 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/WagonPlanGrid.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/WagonPlanGrid.tsx
@@ -6,6 +6,7 @@ type WagonSlot = (WagonPlanRow & { physicalWagonNumber?: string | null }) | {
   sequenceNo: number;
   capacityTons: number;
   assignedWeightTons: number;
+  tareWeightTons?: number | null;
   slotLoadType?: string;
   wagonType?: { code: string } | null;
   wagonTypeCode?: string;
@@ -21,6 +22,8 @@ type WagonSlot = (WagonPlanRow & { physicalWagonNumber?: string | null }) | {
   }>;
 };
 
+const round1 = (n: number) => Math.round(n * 10) / 10;
+
 function loadTypeColor(loadType: string | undefined, freightType?: string | null) {
   const normalized = loadType?.toUpperCase() ?? "";
   if (normalized.includes("BULK")) return "orange";
@@ -68,8 +71,16 @@ export function WagonPlanGrid({
     );
   }
 
-  const totalCapacity = wagonPlan.reduce((sum, w) => sum + w.capacityTons, 0);
-  const totalAssigned = wagonPlan.reduce((sum, w) => sum + w.assignedWeightTons, 0);
+  // GROSS on both sides: cargo + tare vs rated payload + tare.
+  const totalTare = round1(
+    wagonPlan.reduce((sum, w) => sum + (Number(w.tareWeightTons) || 0), 0),
+  );
+  const totalCapacity = round1(
+    wagonPlan.reduce((sum, w) => sum + w.capacityTons, 0) + totalTare,
+  );
+  const totalAssigned = round1(
+    wagonPlan.reduce((sum, w) => sum + w.assignedWeightTons, 0) + totalTare,
+  );
   const usedSlots = wagonPlan.filter((w) => (w.allocations?.length ?? 0) > 0).length;
 
   const isBulk = freightType === "BULK" || wagonPlan.every((w) => w.slotLoadType === "BULK" || (!w.slotLoadType && w.allocations?.[0]?.loadType === "Bulk"));
@@ -82,7 +93,7 @@ export function WagonPlanGrid({
         </Text>
         {isBulk ? (
           <Text size="sm" c="dimmed">
-            Load: <strong>{totalAssigned}</strong> / {totalCapacity}T
+            Gross: <strong>{totalAssigned}</strong> / {totalCapacity}T
           </Text>
         ) : null}
       </Group>
@@ -90,8 +101,9 @@ export function WagonPlanGrid({
       <SimpleGrid cols={{ base: 1, sm: 2, xl: 3 }} spacing="md">
         {wagonPlan.map((wagon) => {
           const seq = wagon.sequenceNo;
-          const capacity = wagon.capacityTons;
-          const assigned = wagon.assignedWeightTons;
+          const tare = Number(wagon.tareWeightTons) || 0;
+          const capacity = round1(wagon.capacityTons + tare);
+          const assigned = round1(wagon.assignedWeightTons + tare);
           const allocations = wagon.allocations ?? [];
           const utilization = capacity > 0 ? Math.min(100, Math.round((assigned / capacity) * 100)) : 0;
           const label = slotLabel(wagon, freightType);
@@ -149,7 +161,7 @@ export function WagonPlanGrid({
                             </Text>
                             {label === "BULK" ? (
                               <Text size="xs" c="dimmed">
-                                {alloc.allocatedWeightTons}T
+                                {alloc.allocatedWeightTons}T cargo
                               </Text>
                             ) : null}
                           </Group>
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/BookingDetailModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/BookingDetailModal.tsx
index 00df4700c..9e7062ad6 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/BookingDetailModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/BookingDetailModal.tsx
@@ -132,7 +132,7 @@ export const BookingDetailModal = ({
           />
           <InfoRow
             icon={<Weight size={15} />}
-            label="Weight"
+            label="Gross weight"
             value={
               <Text size="sm" fw={700}>
                 {booking.weightTons != null ? `${booking.weightTons.toFixed(1)} T` : "—"}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/InteractiveTrainConsist.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/InteractiveTrainConsist.tsx
index 8af9a6e34..8ac374c1a 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/InteractiveTrainConsist.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/InteractiveTrainConsist.tsx
@@ -161,8 +161,11 @@ function WagonCar({
   const allocation = wagon.allocations?.[0];
   const isEmpty = !allocation;
   const isBulk = (allocation?.loadType ?? "").toUpperCase().includes("BULK");
-  const assigned = allocation?.allocatedWeightTons ?? wagon.assignedWeightTons ?? 0;
-  const capacity = wagon.capacityTons ?? 0;
+  // GROSS on both sides: cargo + tare vs rated payload + tare.
+  const tare = wagon.tareWeightTons ?? 0;
+  const assigned =
+    (allocation?.allocatedWeightTons ?? wagon.assignedWeightTons ?? 0) + tare;
+  const capacity = (wagon.capacityTons ?? 0) + tare;
   const utilization = capacity > 0 ? Math.min(100, Math.round((assigned / capacity) * 100)) : 0;
   const accent = isEmpty ? "gray" : isBulk ? "orange" : "cyan";
   const accentVar = `var(--mantine-color-${accent}-6)`;
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/RemoveBookingModal.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/RemoveBookingModal.tsx
index 4d2b1369c..80cbeaad6 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/RemoveBookingModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/RemoveBookingModal.tsx
@@ -21,6 +21,8 @@ export const RemoveBookingModal = ({
   if (!wagon || !wagon.allocations?.[0]) return null;
 
   const allocation = wagon.allocations[0];
+  // GROSS: allocated cargo + the tare of the wagon it sits on.
+  const grossTons = (allocation.allocatedWeightTons ?? 0) + (wagon.tareWeightTons ?? 0);
 
   return (
     <Modal opened={opened} onClose={onClose} title="Confirm Booking Removal" centered>
@@ -40,7 +42,7 @@ export const RemoveBookingModal = ({
               </Badge>
             </Text>
             <Text size="sm">
-              <strong>Weight:</strong> {allocation.allocatedWeightTons?.toFixed(2) || 0} T
+              <strong>Gross weight:</strong> {grossTons.toFixed(2)} T
             </Text>
             <Text size="sm">
               <strong>Wagon Slot:</strong> #{wagon.sequenceNo}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainConsistView.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainConsistView.tsx
index 6ece98ef2..e5b12fe1c 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainConsistView.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainConsistView.tsx
@@ -93,10 +93,14 @@ export const TrainConsistView = ({
     }
   };
 
-  const weightUsed = wagons.reduce(
-    (sum, w) => sum + (w.allocations?.[0]?.allocatedWeightTons ?? 0),
+  // GROSS: cargo on every allocation + the tare of every wagon in the consist.
+  // maxPullWeightTons is a gross limit, so the numerator must be gross too.
+  const cargoUsed = wagons.reduce(
+    (sum, w) => sum + (w.allocations ?? []).reduce((a, al) => a + (al.allocatedWeightTons ?? 0), 0),
     0,
   );
+  const tareUsed = wagons.reduce((sum, w) => sum + (w.tareWeightTons ?? 0), 0);
+  const weightUsed = cargoUsed + tareUsed;
   const lengthUsed = wagons.reduce((sum, w) => sum + (w.lengthMeters ?? 0), 0);
 
   return (
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainStatsBar.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainStatsBar.tsx
index 8ec1c7f4e..3403258ef 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainStatsBar.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/TrainStatsBar.tsx
@@ -98,7 +98,7 @@ export const TrainStatsBar = ({
       <SimpleGrid cols={{ base: 1, xs: 3 }} spacing="lg">
         <StatTile
           icon={<Weight size={15} />}
-          label="Weight"
+          label="Gross weight"
           pct={weightPct}
           current={weightUsed.toFixed(1)}
           max={weightMax?.toFixed(1) ?? "∞"}
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/UnassignedBookingsPanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/UnassignedBookingsPanel.tsx
index e5225f8dd..3af00fd88 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/UnassignedBookingsPanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/UnassignedBookingsPanel.tsx
@@ -130,7 +130,9 @@ export const UnassignedBookingsPanel = ({
 
       {bookings.map((booking) => {
         const isActive = selectedBookingId === booking.id;
-        const weight = Number(booking.cargoTotalWeightVgm ?? 0);
+        // GROSS (cargo + wagon tare) so this badge shares the axis every other
+        // weight on the page uses — cargo-only here read ~25% light.
+        const weight = Number(booking.grossWeightTons ?? booking.cargoTotalWeightVgm ?? 0);
         const fits = booking.canAssign;
         const blockReason = booking.blockReason;
 
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/WagonCard.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/WagonCard.tsx
index f735e6474..915cfa629 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/WagonCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/compositionEditor/WagonCard.tsx
@@ -36,8 +36,12 @@ export const WagonCard = ({
   const hasAllocations = Boolean(allocation);
   const isBulk = (allocation?.loadType ?? "").toUpperCase().includes("BULK");
 
-  const weightUsed = allocation?.allocatedWeightTons ?? 0;
-  const weightMax = wagon.capacityTons ?? 0;
+  // GROSS on both sides: loaded cargo + wagon tare, against the wagon's max
+  // gross (rated payload + tare). Keeps the wagon axis identical to the train
+  // axis in TrainStatsBar.
+  const tare = wagon.tareWeightTons ?? 0;
+  const weightUsed = (allocation?.allocatedWeightTons ?? 0) + tare;
+  const weightMax = (wagon.capacityTons ?? 0) + tare;
   const weightPercent = weightMax ? (weightUsed / weightMax) * 100 : 0;
 
   const wagonType = wagon.wagonType?.code || "UNKNOWN";
diff --git a/apps/edr-freight-web/backoffice/src/constants/trainRuns.ts b/apps/edr-freight-web/backoffice/src/constants/trainRuns.ts
index b7af36639..1ae998c23 100644
--- a/apps/edr-freight-web/backoffice/src/constants/trainRuns.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/trainRuns.ts
@@ -54,10 +54,26 @@ export const TRAIN_RUN_FILTER_OPTIONS = Object.entries(TRAIN_RUN_PAIRS).map(
   }),
 );
 
-/** The import run implied by an export run; empty string when unset/unknown. */
-export const importRunFor = (exportRun: unknown): string =>
-  TRAIN_RUN_PAIRS[String(exportRun ?? "")] ?? "";
+/**
+ * The import run implied by an export run; empty string when unset/unknown.
+ * Runs outside the hardcoded pairs (admin-added via dropdown settings) fall
+ * back to the numeric convention: import = export + 1.
+ */
+export const importRunFor = (exportRun: unknown): string => {
+  const run = String(exportRun ?? "");
+  const paired = TRAIN_RUN_PAIRS[run];
+  if (paired) return paired;
+  return /^\d*[13579]$/.test(run) ? String(Number(run) + 1) : "";
+};
 
-/** The export run implied by an import run; empty string when unset/unknown. */
-export const exportRunFor = (importRun: unknown): string =>
-  EXPORT_BY_IMPORT[String(importRun ?? "")] ?? "";
+/**
+ * The export run implied by an import run; empty string when unset/unknown.
+ * Runs outside the hardcoded pairs (admin-added via dropdown settings) fall
+ * back to the numeric convention: export = import − 1.
+ */
+export const exportRunFor = (importRun: unknown): string => {
+  const run = String(importRun ?? "");
+  const paired = EXPORT_BY_IMPORT[run];
+  if (paired) return paired;
+  return /^\d*[02468]$/.test(run) && Number(run) > 0 ? String(Number(run) - 1) : "";
+};
diff --git a/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts b/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
index bc10fd064..a0594094c 100644
--- a/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
+++ b/apps/edr-freight-web/backoffice/src/features/bookings/mapBookingListRow.ts
@@ -19,6 +19,7 @@ export function toBookingListRow(booking: BookingDetail): BookingListRow {
     id: booking.id,
     reference: booking.reference,
     contractReference: booking.contractReference ?? null,
+    contractId: booking.contractId ?? null,
     approvalSteps: booking.approvalSteps,
     customerLabel: booking.isGovernment
       ? (booking.governmentInstitution ?? "Government")
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useImportTrainNumberOptions.ts b/apps/edr-freight-web/backoffice/src/hooks/useImportTrainNumberOptions.ts
new file mode 100644
index 000000000..a26e127f3
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/hooks/useImportTrainNumberOptions.ts
@@ -0,0 +1,67 @@
+import { useQuery } from "@tanstack/react-query";
+import { useMemo } from "react";
+
+import { IMPORT_TRAIN_OPTIONS } from "@/constants/trainRuns";
+import { api } from "@/services/api";
+
+/** Dropdown-settings code holding the admin-managed IMPORT run numbers. */
+export const IMPORT_TRAIN_NUMBERS_CODE = "import_train_numbers";
+
+export interface ImportTrainNumberOption {
+  value: string;
+  label: string;
+  disabled?: boolean;
+}
+
+/**
+ * Selectable IMPORT run numbers for the Train Builder, sourced from the
+ * admin-managed `import_train_numbers` dropdown setting (admins add new runs
+ * from the Dropdown Settings editor). Falls back to the legacy hardcoded run
+ * list while the setting is missing or has no options.
+ *
+ * Numbers already claimed by an existing train are kept in the list but
+ * disabled and tagged "in use". Pass `currentNumber` when editing a train so
+ * its own number stays pickable, and so a legacy number that was removed from
+ * the setting still renders.
+ */
+export function useImportTrainNumberOptions(currentNumber?: string | null) {
+  const settingQuery = useQuery(
+    api.dropdownSettings.getByCode.queryOptions({
+      input: { code: IMPORT_TRAIN_NUMBERS_CODE },
+      staleTime: 5 * 60_000,
+      retry: false,
+    }),
+  );
+  const usedQuery = useQuery(
+    api.trainBuilder.usedTrainNumbers.queryOptions({ staleTime: 30_000 }),
+  );
+
+  const options = useMemo<ImportTrainNumberOption[]>(() => {
+    const configured = [...(settingQuery.data?.children ?? [])]
+      .filter((option) => !option.disabled)
+      .sort((a, b) => (a.order ?? 0) - (b.order ?? 0))
+      .map((option) => ({
+        value: option.value,
+        label: option.label || option.value,
+      }));
+    const base = configured.length ? configured : IMPORT_TRAIN_OPTIONS;
+
+    const used = new Set(usedQuery.data?.importTrainNumbers ?? []);
+    if (currentNumber) used.delete(currentNumber);
+
+    const items: ImportTrainNumberOption[] = base.map((option) =>
+      used.has(option.value)
+        ? { ...option, label: `${option.label} — in use`, disabled: true }
+        : option,
+    );
+    if (currentNumber && !items.some((option) => option.value === currentNumber)) {
+      items.unshift({ value: currentNumber, label: currentNumber });
+    }
+    return items;
+  }, [settingQuery.data, usedQuery.data, currentNumber]);
+
+  return {
+    options,
+    isLoading: settingQuery.isLoading || usedQuery.isLoading,
+  };
+}
diff --git a/apps/edr-freight-web/backoffice/src/lib/queryClient.ts b/apps/edr-freight-web/backoffice/src/lib/queryClient.ts
index 5b2bcb255..0a270372e 100644
--- a/apps/edr-freight-web/backoffice/src/lib/queryClient.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/queryClient.ts
@@ -27,7 +27,8 @@ export const queryClient = new QueryClient({
   defaultOptions: {
     queries: {
       retry: 1,
-      staleTime: 30_000,
+      // staleTime: 30_000,
+      staleTime:0,
       // Data freshness is driven by mutation invalidation (MutationCache above),
       // socket pushes, and explicit polling — not by tab focus. Focus refetch
       // just re-fires every mounted query each time the window is refocused.
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
index 72c16215b..3eb775e95 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
@@ -48,6 +48,7 @@ import {
   useBookingList,
   useBookingListSummary,
 } from "@/hooks/bookings/useBookings";
+import { ContractReferenceLink } from "@/components/bookings/ContractReferenceLink";
 import { api } from "@/services/api";
 import type { BookingListFilter } from "@/services/bookings.service";
 import type { BookingListRow } from "@/types/booking";
@@ -308,7 +309,17 @@ export default function BookingRequestsPage() {
         return (
           <div className="py-1">
             {ref ? (
-              <span className="truncate font-mono text-xs text-foreground">{ref}</span>
+              // Fall back to plain text when the id is missing — the reference is
+              // still worth showing, it just has nowhere to link to.
+              (row.original.contractId ? (
+                <ContractReferenceLink
+                  contractId={row.original.contractId}
+                  contractReference={ref}
+                  className="truncate font-mono text-xs text-foreground underline underline-offset-2 hover:text-primary"
+                />
+              ) : (
+                <span className="truncate font-mono text-xs text-foreground">{ref}</span>
+              ))
             ) : (
               <span className="text-xs text-muted-foreground">—</span>
             )}
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 79d35aa7d..7be7871dd 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/DocumentClearanceDetailPage.tsx
@@ -23,6 +23,7 @@ import {
   Clock,
   PackageCheck,
   PackagePlus,
+  RotateCcw,
   ShieldCheck,
 } from "lucide-react";
 import type { Freight } from "@edr/types";
@@ -110,6 +111,16 @@ export default function DocumentClearanceDetailPage() {
     hasPermission(user, FREIGHT_PERMS.contracts.createBooking) &&
     !isDjiboutiGl(user);
 
+  // The completed booking expired unpaid at train dispatch. Its per-booking
+  // clearance is finished, so GL rebooks it onto a new day — the customer never
+  // re-requests the shipment or pays the clearance fee again.
+  const canRebookExpired =
+    booking?.status === "EXPIRED" &&
+    Boolean(booking?.contractId) &&
+    Number(booking?.totalAmount ?? 0) > 0 &&
+    hasPermission(user, FREIGHT_PERMS.contracts.createBooking) &&
+    !isDjiboutiGl(user);
+
   const docsPhaseComplete =
     clearance?.milestones?.some(
       (m) => m.milestoneCode === "DOCUMENTS_APPROVED" && m.status === "COMPLETED",
@@ -194,6 +205,19 @@ export default function DocumentClearanceDetailPage() {
               >
                 Create booking
               </Button>
+            ) : canRebookExpired ? (
+              <Button
+                color="edr-green"
+                radius="md"
+                leftSection={<RotateCcw size={16} />}
+                onClick={() =>
+                  navigate(
+                    `/dashboard/contracts/${booking!.contractId}/bookings/${id}/complete?copyFrom=${id}`,
+                  )
+                }
+              >
+                Rebook shipment
+              </Button>
             ) : undefined
           }
         />
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 5b365bc9d..945d142df 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ClearanceDocumentsPage.tsx
@@ -452,7 +452,9 @@ export default function ClearanceDocumentsPage() {
                     data={contractRows}
                     status={tableStatus}
                     onRowClick={(row) =>
-                      navigate(`/dashboard/contracts/clearance/${row.id}`)
+                      navigate(
+                        `/dashboard/contracts/clearance-documents/${row.id}`,
+                      )
                     }
                     pagination={{
                       pageIndex: pagination.pageIndex,
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
index 6c8565d03..63dbb5d0b 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceDetailPage.tsx
@@ -1,6 +1,6 @@
 import { useMemo } from "react";
 import { useQuery } from "@tanstack/react-query";
-import { useParams } from "react-router-dom";
+import { useLocation, useParams } from "react-router-dom";
 import {
   Alert,
   Badge,
@@ -52,9 +52,21 @@ import {
 
 export default function ContractClearanceDetailPage() {
   const { id } = useParams<{ id: string }>();
+  const { pathname } = useLocation();
   const { view, viewer } = useFileViewer();
   const { user } = useAuth();
 
+  // The same detail page serves two hubs: the GL "Document Clearance" list and
+  // the Operations "Clearance Documents" list. Point back-navigation at
+  // whichever hub the user came through.
+  const fromOpsHub = pathname.startsWith(
+    "/dashboard/contracts/clearance-documents",
+  );
+  const hubHref = fromOpsHub
+    ? "/dashboard/contracts/clearance-documents"
+    : "/dashboard/contracts/clearance";
+  const hubLabel = fromOpsHub ? "Clearance Documents" : "Document Clearance";
+
   const { data: contract, refetch: refetchContract } = useContractDetail(id);
   const {
     data: clearance,
@@ -153,12 +165,9 @@ export default function ContractClearanceDetailPage() {
       <PageContainer>
         <PageHeader
           title="Clearance not found"
-          backTo="/dashboard/contracts/clearance"
+          backTo={hubHref}
           breadcrumbs={[
-            {
-              label: "Document Clearance",
-              href: "/dashboard/contracts/clearance",
-            },
+            { label: hubLabel, href: hubHref },
             { label: "Not found" },
           ]}
         />
@@ -176,12 +185,9 @@ export default function ContractClearanceDetailPage() {
       <Stack gap="lg">
         <PageHeader
           title={reference}
-          backTo="/dashboard/contracts/clearance"
+          backTo={hubHref}
           breadcrumbs={[
-            {
-              label: "Document Clearance",
-              href: "/dashboard/contracts/clearance",
-            },
+            { label: hubLabel, href: hubHref },
             { label: reference },
           ]}
           meta={
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 c18311ad2..9cc9919e3 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractClearanceListPage.tsx
@@ -197,6 +197,29 @@ function DirectionIcon({ direction }: { direction: string }) {
 }
 
 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
@@ -727,8 +750,12 @@ export default function ContractClearanceListPage() {
                   )
                 }
                 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}/create-booking?copyFrom=${row.id}`,
+                    `/dashboard/contracts/${row.contractId}/bookings/${row.id}/complete?copyFrom=${row.id}`,
                   )
                 }
                 onViewContract={(contractId) =>
@@ -813,6 +840,17 @@ const shipmentStatusColor = (s: string) => {
   if (s === "AWAITING_DOCUMENTS") return "yellow";
   if (s === "DOCUMENTS_UNDER_REVIEW") return "blue";
   if (s === "CLEARANCE_READY") return "edr-green";
+  if (
+    [
+      "SELECTED_FOR_BATCH",
+      "PNR_GENERATED",
+      "AWAITING_PAYMENT",
+      "PAYMENT_VERIFICATION_IN_PROGRESS",
+    ].includes(s)
+  )
+    return "violet";
+  if (s === "EXPIRED") return "orange";
+  if (s === "CANCELLED" || s === "REJECTED") return "red";
   return "gray";
 };
 
diff --git a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
index ea4e78691..1752aa7c0 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/ContractRequestsPage.tsx
@@ -4,11 +4,14 @@ import {
   Button,
   Card,
   Group,
+  MultiSelect,
+  Select,
   Stack,
   Text,
   TextInput,
   ThemeIcon,
 } from "@mantine/core";
+import { DateInput } from "@mantine/dates";
 import { useDebouncedValue } from "@mantine/hooks";
 import {
   AlertTriangle,
@@ -17,6 +20,7 @@ import {
   CheckCircle2,
   Clock,
   FileText,
+  FilterX,
   Inbox,
   LayoutList,
   RefreshCw,
@@ -36,7 +40,10 @@ import {
 } from "@/components/contracts/ContractStatusTabs";
 import { bookingTable } from "@/components/bookings/booking-ui.styles";
 import { KpiStrip, PageContainer, PageHeader } from "@/components/page";
-import { CONTRACT_LIST_TABS } from "@/features/contracts/contract-status.config";
+import {
+  CONTRACT_LIST_TABS,
+  CONTRACT_STATUS_STYLES,
+} from "@/features/contracts/contract-status.config";
 import {
   getStaffRowAction,
   toContractListRow,
@@ -61,6 +68,63 @@ function getStatusesForTab(tab: ContractStatusTabKey): string | undefined {
   return match.statuses.join(",");
 }
 
+/** Statuses selectable in the status filter for a given tab ("all" → every tab status). */
+function getStatusOptionsForTab(
+  tab: ContractStatusTabKey,
+): { value: string; label: string }[] {
+  const match = CONTRACT_LIST_TABS.find((t) => t.key === tab);
+  const statuses = match?.statuses?.length
+    ? match.statuses
+    : CONTRACT_LIST_TABS.flatMap((t) => t.statuses ?? []);
+  return statuses.map((s) => ({
+    value: s,
+    label: CONTRACT_STATUS_STYLES[s]?.label ?? s,
+  }));
+}
+
+const TRADE_DIRECTION_OPTIONS = [
+  { value: "IMPORT", label: "Import" },
+  { value: "EXPORT", label: "Export" },
+  { value: "DOMESTIC", label: "Domestic" },
+];
+
+const FREIGHT_TYPE_OPTIONS = [
+  { value: "CONTAINER", label: "Container" },
+  { value: "BULK", label: "Bulk" },
+];
+
+const CONTRACT_KIND_OPTIONS = [
+  { value: "GENERAL", label: "General (recurring)" },
+  { value: "ONE_TIME", label: "One-time" },
+];
+
+const CURRENCY_OPTIONS = [
+  { value: "ETB", label: "ETB" },
+  { value: "USD", label: "USD" },
+];
+
+/** value = `${sortBy}:${sortOrder}` for the sort Select. */
+const SORT_OPTIONS = [
+  { value: "createdAt:DESC", label: "Newest first" },
+  { value: "createdAt:ASC", label: "Oldest first" },
+  { value: "contractValidUntil:ASC", label: "Expiring soonest" },
+  { value: "contractValidUntil:DESC", label: "Expiring latest" },
+];
+
+/** Local start-of-day → ISO, for inclusive "from" date filters. */
+function startOfDayIso(d: Date): string {
+  const x = new Date(d);
+  x.setHours(0, 0, 0, 0);
+  return x.toISOString();
+}
+
+/** Local end-of-day → ISO, for inclusive "to" date filters. */
+function endOfDayIso(d: Date): string {
+  const x = new Date(d);
+  x.setHours(23, 59, 59, 999);
+  return x.toISOString();
+}
+
 function formatDate(value: string | null | undefined): string {
   if (!value) return "—";
   const d = new Date(value);
@@ -79,32 +143,86 @@ export default function ContractRequestsPage() {
   const [query, setQuery] = useState("");
   const [debouncedQuery] = useDebouncedValue(query, 300);
   const [activeTab, setActiveTab] = useState<ContractStatusTabKey>("all");
+  // Filter controls (empty/null = "all").
+  const [statusFilter, setStatusFilter] = useState<string[]>([]);
+  const [directionFilter, setDirectionFilter] = useState<string | null>(null);
+  const [freightTypeFilter, setFreightTypeFilter] = useState<string | null>(
+    null,
+  );
+  const [kindFilter, setKindFilter] = useState<string | null>(null);
+  const [currencyFilter, setCurrencyFilter] = useState<string | null>(null);
+  const [createdFrom, setCreatedFrom] = useState<Date | null>(null);
+  const [createdTo, setCreatedTo] = useState<Date | null>(null);
+  const [sort, setSort] = useState<string>("createdAt:DESC");
 
   const tabStatuses = getStatusesForTab(activeTab);
+  const statusOptions = useMemo(
+    () => getStatusOptionsForTab(activeTab),
+    [activeTab],
+  );
 
   const resetPage = useCallback(() => {
     setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
   }, [setPagination, pagination.pageSize]);
 
-  const filter: ContractListFilter = useMemo(
-    () => ({
+  const filter: ContractListFilter = useMemo(() => {
+    const [sortBy, sortOrder] = sort.split(":") as [string, "ASC" | "DESC"];
+    return {
       page: pagination.pageIndex + 1,
       pageSize: pagination.pageSize,
-      sortBy: "createdAt",
-      sortOrder: "DESC",
+      sortBy,
+      sortOrder,
       tab: activeTab,
       // Server-side free-text search (contract reference, customer name).
       ...(debouncedQuery.trim() ? { search: debouncedQuery.trim() } : {}),
-      ...(tabStatuses ? { statuses: tabStatuses } : {}),
-    }),
-    [
-      pagination.pageIndex,
-      pagination.pageSize,
-      activeTab,
-      tabStatuses,
-      debouncedQuery,
-    ],
-  );
+      // Explicit status picks narrow within the tab; otherwise the tab's
+      // status group applies.
+      ...(statusFilter.length
+        ? { statuses: statusFilter.join(",") }
+        : tabStatuses
+          ? { statuses: tabStatuses }
+          : {}),
+      ...(directionFilter ? { tradeDirection: directionFilter } : {}),
+      ...(freightTypeFilter ? { freightType: freightTypeFilter } : {}),
+      ...(kindFilter ? { contractKind: kindFilter } : {}),
+      ...(currencyFilter ? { paymentCurrency: currencyFilter } : {}),
+      ...(createdFrom ? { createdFrom: startOfDayIso(createdFrom) } : {}),
+      ...(createdTo ? { createdTo: endOfDayIso(createdTo) } : {}),
+    };
+  }, [
+    pagination.pageIndex,
+    pagination.pageSize,
+    activeTab,
+    tabStatuses,
+    debouncedQuery,
+    statusFilter,
+    directionFilter,
+    freightTypeFilter,
+    kindFilter,
+    currencyFilter,
+    createdFrom,
+    createdTo,
+    sort,
+  ]);
+
+  const activeFilterCount =
+    (statusFilter.length ? 1 : 0) +
+    (directionFilter ? 1 : 0) +
+    (freightTypeFilter ? 1 : 0) +
+    (kindFilter ? 1 : 0) +
+    (currencyFilter ? 1 : 0) +
+    (createdFrom || createdTo ? 1 : 0);
+
+  const clearFilters = useCallback(() => {
+    setStatusFilter([]);
+    setDirectionFilter(null);
+    setFreightTypeFilter(null);
+    setKindFilter(null);
+    setCurrencyFilter(null);
+    setCreatedFrom(null);
+    setCreatedTo(null);
+    setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
+  }, [setPagination, pagination.pageSize]);
 
   const { data, isLoading, isError, refetch, isFetching } =
     useContractList(filter);
@@ -341,6 +459,8 @@ export default function ContractRequestsPage() {
           active={activeTab}
           onChange={(tab) => {
             setActiveTab(tab);
+            // Status picks belong to the previous tab's option set — reset.
+            setStatusFilter([]);
             setPagination({ pageIndex: 0, pageSize: pagination.pageSize });
           }}
           counts={tabCounts}
@@ -349,38 +469,159 @@ export default function ContractRequestsPage() {
         <Card p={0}>
           <Stack gap={0}>
             <Box px="md" pt="md" pb="sm" w="100%">
-              <Group justify="space-between" gap="md" wrap="wrap">
-                <TextInput
-                  placeholder="Search reference or customer…"
-                  leftSection={<Search size={18} />}
-                  value={query}
-                  onChange={(e) => {
-                    setQuery(e.target.value);
-                    resetPage();
-                  }}
-                  rightSection={
-                    query && (
-                      <ActionIcon
-                        size="sm"
-                        color="gray"
-                        radius="md"
-                        variant="transparent"
-                        onClick={() => {
-                          setQuery("");
-                          resetPage();
-                        }}
-                      >
-                        <X size={16} />
-                      </ActionIcon>
-                    )
-                  }
-                  style={{ flex: 1, minWidth: "200px" }}
-                  radius="lg"
-                />
-                <Text size="sm" c="dimmed">
-                  {total} record{total !== 1 ? "s" : ""}
-                </Text>
-              </Group>
+              <Stack gap="sm">
+                <Group justify="space-between" gap="md" wrap="wrap">
+                  <TextInput
+                    placeholder="Search reference or customer…"
+                    leftSection={<Search size={18} />}
+                    value={query}
+                    onChange={(e) => {
+                      setQuery(e.target.value);
+                      resetPage();
+                    }}
+                    rightSection={
+                      query && (
+                        <ActionIcon
+                          size="sm"
+                          color="gray"
+                          radius="md"
+                          variant="transparent"
+                          onClick={() => {
+                            setQuery("");
+                            resetPage();
+                          }}
+                        >
+                          <X size={16} />
+                        </ActionIcon>
+                      )
+                    }
+                    style={{ flex: 1, minWidth: "200px" }}
+                    radius="lg"
+                  />
+                  <Select
+                    data={SORT_OPTIONS}
+                    value={sort}
+                    onChange={(v) => {
+                      setSort(v ?? "createdAt:DESC");
+                      resetPage();
+                    }}
+                    allowDeselect={false}
+                    radius="lg"
+                    style={{ minWidth: 170 }}
+                    aria-label="Sort contracts"
+                  />
+                  <Text size="sm" c="dimmed">
+                    {total} record{total !== 1 ? "s" : ""}
+                  </Text>
+                </Group>
+                <Group gap="sm" wrap="wrap">
+                  <MultiSelect
+                    placeholder={
+                      statusFilter.length ? undefined : "All statuses"
+                    }
+                    data={statusOptions}
+                    value={statusFilter}
+                    onChange={(v) => {
+                      setStatusFilter(v);
+                      resetPage();
+                    }}
+                    clearable
+                    searchable
+                    radius="lg"
+                    style={{ minWidth: 220 }}
+                    aria-label="Filter by status"
+                  />
+                  <Select
+                    placeholder="All directions"
+                    data={TRADE_DIRECTION_OPTIONS}
+                    value={directionFilter}
+                    onChange={(v) => {
+                      setDirectionFilter(v);
+                      resetPage();
+                    }}
+                    clearable
+                    radius="lg"
+                    style={{ minWidth: 150 }}
+                    aria-label="Filter by trade direction"
+                  />
+                  <Select
+                    placeholder="All freight types"
+                    data={FREIGHT_TYPE_OPTIONS}
+                    value={freightTypeFilter}
+                    onChange={(v) => {
+                      setFreightTypeFilter(v);
+                      resetPage();
+                    }}
+                    clearable
+                    radius="lg"
+                    style={{ minWidth: 160 }}
+                    aria-label="Filter by freight type"
+                  />
+                  <Select
+                    placeholder="All kinds"
+                    data={CONTRACT_KIND_OPTIONS}
+                    value={kindFilter}
+                    onChange={(v) => {
+                      setKindFilter(v);
+                      resetPage();
+                    }}
+                    clearable
+                    radius="lg"
+                    style={{ minWidth: 160 }}
+                    aria-label="Filter by contract kind"
+                  />
+                  <Select
+                    placeholder="All currencies"
+                    data={CURRENCY_OPTIONS}
+                    value={currencyFilter}
+                    onChange={(v) => {
+                      setCurrencyFilter(v);
+                      resetPage();
+                    }}
+                    clearable
+                    radius="lg"
+                    style={{ minWidth: 140 }}
+                    aria-label="Filter by payment currency"
+                  />
+                  <DateInput
+                    placeholder="Created from"
+                    value={createdFrom}
+                    onChange={(v) => {
+                      setCreatedFrom(v ? new Date(v) : null);
+                      resetPage();
+                    }}
+                    maxDate={createdTo ?? undefined}
+                    clearable
+                    radius="lg"
+                    style={{ minWidth: 140 }}
+                    aria-label="Created from"
+                  />
+                  <DateInput
+                    placeholder="Created to"
+                    value={createdTo}
+                    onChange={(v) => {
+                      setCreatedTo(v ? new Date(v) : null);
+                      resetPage();
+                    }}
+                    minDate={createdFrom ?? undefined}
+                    clearable
+                    radius="lg"
+                    style={{ minWidth: 140 }}
+                    aria-label="Created to"
+                  />
+                  {activeFilterCount > 0 ? (
+                    <Button
+                      variant="subtle"
+                      color="gray"
+                      radius="lg"
+                      leftSection={<FilterX size={16} />}
+                      onClick={clearFilters}
+                    >
+                      Clear filters ({activeFilterCount})
+                    </Button>
+                  ) : null}
+                </Group>
+              </Stack>
             </Box>
 
             {showEmpty ? (
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 daff48939..f68d6562b 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/GlClearanceDetailPage.tsx
@@ -1,6 +1,6 @@
 import { useState } from "react";
 import { useQuery } from "@tanstack/react-query";
-import { useNavigate, useParams } from "react-router-dom";
+import { useParams } from "react-router-dom";
 import {
   Alert,
   Badge,
@@ -18,7 +18,6 @@ import {
   AlertCircle,
   ClipboardList,
   FileText,
-  PackagePlus,
   Upload,
 } from "lucide-react";
 import type { Freight } from "@edr/types";
@@ -61,9 +60,12 @@ type GlClearanceDetail =
 
 async function loadGlClearanceDetail(id: string): Promise<GlClearanceDetail> {
   try {
+    // Probe the contract endpoints first; a booking-id row 404s here by design
+    // and falls back to the booking lookup below. Suppress the global error
+    // modal so that expected 404 never surfaces to the user.
     const [clearance, contract] = await Promise.all([
-      contractsService.getClearance(id),
-      contractsService.getById(id),
+      contractsService.getClearance(id, { suppressErrorModal: true }),
+      contractsService.getById(id, { suppressErrorModal: true }),
     ]);
     return {
       kind: "contract",
@@ -89,7 +91,6 @@ async function loadGlClearanceDetail(id: string): Promise<GlClearanceDetail> {
 /** Djibouti GL clearance detail — RO/DO upload and read-only upstream context. */
 export default function GlClearanceDetailPage() {
   const { id } = useParams<{ id: string }>();
-  const navigate = useNavigate();
   const { user } = useAuth();
   const { view, viewer } = useFileViewer();
   const [uploadKind, setUploadKind] = useState<GlClearanceUploadKind | null>(null);
@@ -197,19 +198,6 @@ export default function GlClearanceDetailPage() {
                   {hasRo ? "Replace RO" : "Upload RO"}
                 </Button>
               )}
-              {canCompleteBooking && shipmentBooking ? (
-                <Button
-                  color="edr-green"
-                  leftSection={<PackagePlus size={16} />}
-                  onClick={() =>
-                    navigate(
-                      `/dashboard/contracts/${shipmentBooking.contractId}/bookings/${id}/complete`,
-                    )
-                  }
-                >
-                  Create booking
-                </Button>
-              ) : null}
             </Group>
           }
         />
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 bb0edcadb..a43a6ff55 100644
--- a/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/contracts/GlDjiboutiClearanceListPage.tsx
@@ -106,6 +106,18 @@ function statusColor(status: string): string {
     case "ACTIVE_SHIPMENT_IN_PROGRESS":
     case "IN_TRANSIT":
       return "teal";
+    // Payment phase — booking selected / awaiting the customer's payment.
+    case "SELECTED_FOR_BATCH":
+    case "PNR_GENERATED":
+    case "AWAITING_PAYMENT":
+    case "PAYMENT_VERIFICATION_IN_PROGRESS":
+      return "violet";
+    // Terminal rows kept as clearance history.
+    case "EXPIRED":
+      return "orange";
+    case "CANCELLED":
+    case "REJECTED":
+      return "red";
     default:
       return "gray";
   }
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 378bb5aad..16f55cf00 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderDetailPage.tsx
@@ -18,6 +18,8 @@ import {
   CalendarClock,
   MapPin,
   MoreHorizontal,
+  Power,
+  PowerOff,
   Replace,
   Ruler,
   Trash2,
@@ -70,6 +72,7 @@ export default function TrainBuilderDetailPage() {
   const [locoModalOpen, setLocoModalOpen] = useState(false);
   const [yardModalOpen, setYardModalOpen] = useState(false);
   const [disbandOpen, setDisbandOpen] = useState(false);
+  const [deactivateOpen, setDeactivateOpen] = useState(false);
 
   const compositionQuery = useQuery(
     api.trainBuilder.composition.queryOptions({ input: { id }, enabled: Boolean(id) }),
@@ -81,6 +84,8 @@ export default function TrainBuilderDetailPage() {
   );
   const reorderWagons = useMutation(api.trainBuilder.reorderWagons.mutationOptions());
   const disband = useMutation(api.trainBuilder.disband.mutationOptions());
+  const deactivate = useMutation(api.trainBuilder.deactivate.mutationOptions());
+  const activate = useMutation(api.trainBuilder.activate.mutationOptions());
 
   const composition = compositionQuery.data;
   const busy =
@@ -172,6 +177,27 @@ export default function TrainBuilderDetailPage() {
               >
                 Change yard
               </Menu.Item>
+              {composition.status === "DEACTIVATED" ? (
+                <Menu.Item
+                  leftSection={<Power size={15} />}
+                  onClick={() =>
+                    void withToast(async () => {
+                      await activate.mutateAsync(composition.id);
+                      toast({ title: `Train ${composition.code} reactivated` });
+                    }, "Could not reactivate train")
+                  }
+                >
+                  Reactivate train
+                </Menu.Item>
+              ) : (
+                <Menu.Item
+                  leftSection={<PowerOff size={15} />}
+                  disabled={composition.activeSchedules.length > 0}
+                  onClick={() => setDeactivateOpen(true)}
+                >
+                  Deactivate train
+                </Menu.Item>
+              )}
               <Menu.Item
                 color="red"
                 leftSection={<Trash2 size={15} />}
@@ -356,6 +382,39 @@ export default function TrainBuilderDetailPage() {
         onClose={() => setYardModalOpen(false)}
       />
 
+      <Modal
+        opened={deactivateOpen}
+        onClose={() => setDeactivateOpen(false)}
+        title={<Text fw={600}>Deactivate train {composition.code}?</Text>}
+        radius="lg"
+        centered
+      >
+        <Stack gap="md">
+          <Text size="sm" c="dimmed">
+            The train is parked and cannot be picked for new schedules until it is
+            reactivated. Its locomotives and wagons stay coupled.
+          </Text>
+          <Group justify="flex-end">
+            <Button variant="default" onClick={() => setDeactivateOpen(false)}>
+              Keep active
+            </Button>
+            <Button
+              color="gray"
+              loading={deactivate.isPending}
+              onClick={() =>
+                void withToast(async () => {
+                  await deactivate.mutateAsync(composition.id);
+                  toast({ title: `Train ${composition.code} deactivated` });
+                  setDeactivateOpen(false);
+                }, "Could not deactivate train")
+              }
+            >
+              Deactivate
+            </Button>
+          </Group>
+        </Stack>
+      </Modal>
+
       <Modal
         opened={disbandOpen}
         onClose={() => setDisbandOpen(false)}
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderListPage.tsx
index ec54c9aba..c980d55b6 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainBuilder/TrainBuilderListPage.tsx
@@ -315,6 +315,7 @@ export default function TrainBuilderListPage() {
                   { value: "IN_SERVICE", label: "In service" },
                   { value: "UNDER_MAINTENANCE", label: "Under maintenance" },
                   { value: "OUT_OF_SERVICE", label: "Out of service" },
+                  { value: "DEACTIVATED", label: "Deactivated" },
                 ]}
                 w={180}
                 styles={{ input: { borderColor: "var(--mantine-color-gray-3)" } }}
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
index 5cfe550a2..58d027c8c 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/BatchScheduleDetailPage.tsx
@@ -66,8 +66,8 @@ import { useToast } from "@/hooks/use-toast";
 import type {
   BatchBoardBookingDetail,
   BatchBoardBookingState,
+  BatchBoardCounts,
   BatchBoardScheduleDetail,
-  BatchWindowGroup,
   BookingAllocationStatus,
 } from "@/types/trainScheduling";
 
@@ -398,7 +398,7 @@ const BookingTable = memo(function BookingTable({
   );
 });
 
-function WindowCountChips({ counts }: { counts: BatchWindowGroup["counts"] }) {
+function WindowCountChips({ counts }: { counts: BatchBoardCounts }) {
   const chips: Array<{ value: number; color: string; label: string }> = [
     { value: counts.allocated, color: "edr-green", label: "allocated" },
     { value: counts.selectedForBatch, color: "orange", label: "selected" },
@@ -609,9 +609,7 @@ export default function BatchScheduleDetailPage() {
   const hasAssignedWagons = useMemo(
     () =>
       Boolean(
-        data?.windows.some((w) =>
-          w.bookings.some((b) => b.allocationStatus === "ASSIGNED"),
-        ) ||
+        data?.bookings.some((b) => b.allocationStatus === "ASSIGNED") ||
         data?.pendingContract.bookings.some(
           (b) => b.allocationStatus === "ASSIGNED",
         ),
@@ -619,36 +617,33 @@ export default function BatchScheduleDetailPage() {
     [data],
   );
 
+  const [activeTab, setActiveTab] = useState<string | null>("overview");
+
   const scheduleDetailQuery = useQuery(
     api.trainScheduling.scheduleDetail.queryOptions({
       input: { id: scheduleId ?? "", freightType: "CONTAINER" },
-      enabled: Boolean(scheduleId),
+      // The heavy composition graph is only rendered by the composition tab and
+      // the overview diagram (which needs assigned wagons) — don't fetch it
+      // until one of them can actually show something.
+      enabled:
+        Boolean(scheduleId) &&
+        (hasAssignedWagons || activeTab === "composition"),
       // Composition data only changes through mutations, which invalidate the
       // whole train-scheduling root — no need to refetch on remounts in between.
       staleTime: 5 * 60_000,
     }),
   );
 
-  // Every booking on this schedule, flattened across windows + pending-contract,
-  // de-duplicated (a booking only appears once). Feeds the management table.
+  // Every booking on this schedule: in-window + pending-contract (the two
+  // buckets are disjoint). Feeds the management table.
   const allBookings = useMemo(() => {
     if (!data) return [] as BatchBoardBookingDetail[];
-    const merged = [
-      ...data.windows.flatMap((w) => w.bookings),
-      ...data.pendingContract.bookings,
-    ];
-    const byId = new Map<string, BatchBoardBookingDetail>();
-    for (const b of merged) if (!byId.has(b.id)) byId.set(b.id, b);
-    return [...byId.values()];
+    return [...data.bookings, ...data.pendingContract.bookings];
   }, [data]);
 
-  // All bookings that fall inside the schedule's booking window (every window
-  // cycle, flattened) — the window is one booking day, so these belong to the
-  // single window panel above.
-  const windowBookings = useMemo(
-    () => (data?.windows ?? []).flatMap((w) => w.bookings),
-    [data?.windows],
-  );
+  // Bookings inside the schedule's booking window — they belong to the single
+  // window panel above.
+  const windowBookings = data?.bookings ?? [];
 
   const windowCounts = useMemo(() => {
     const counts = {
@@ -684,7 +679,6 @@ export default function BatchScheduleDetailPage() {
     [data?.status],
   );
 
-  const [activeTab, setActiveTab] = useState<string | null>("overview");
   const [adjustConsistOpen, setAdjustConsistOpen] = useState(false);
   const [selectedBookingId, setSelectedBookingId] = useState<string | null>(
     null,
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/IntercityPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/IntercityPage.tsx
index 6a45be0f2..bce1f52e3 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/IntercityPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/IntercityPage.tsx
@@ -40,16 +40,29 @@ const isWaiting = (r: IntercityRideAlongRow) =>
 const isRiding = (r: IntercityRideAlongRow) => r.status === "IN_TRANSIT";
 const isDone = (r: IntercityRideAlongRow) => r.status === "COMPLETED";
 
-/** Yards with no equipment can never load/unload — surface it before the train arrives. */
-function FacilityCell({ yard, has }: { yard: string | null; has: boolean | null }) {
+/**
+ * A yard that can't handle THIS booking's cargo can never work it — surface that
+ * while the train is still coming, not when the load is refused. Containers need
+ * a facility with a stacker (Indode, Modjo, Dire Dawa); bulk is handled at all of
+ * them.
+ */
+function FacilityCell({
+  yard,
+  has,
+  freightType,
+}: {
+  yard: string | null;
+  has: boolean | null;
+  freightType: string | null;
+}) {
   if (!yard) return <Text size="sm">—</Text>;
   if (has) return <Text size="sm">{yard}</Text>;
   return (
     <Tooltip
-      label="This yard has no load/unload facility — cargo cannot be handled here"
+      label={`${yard} cannot handle ${(freightType ?? "this").toLowerCase()} cargo — no facility here, or no equipment for it`}
       withArrow
       multiline
-      w={240}
+      w={260}
     >
       <Group gap={4} wrap="nowrap">
         <AlertTriangle size={13} color="var(--mantine-color-red-6)" />
@@ -95,7 +108,7 @@ function Rows({ rows }: { rows: IntercityRideAlongRow[] }) {
               <Table.Td>{r.customer ?? "—"}</Table.Td>
               <Table.Td>
                 <Group gap={6} wrap="nowrap">
-                  <FacilityCell yard={r.origin} has={r.originHasFacility} />
+                  <FacilityCell yard={r.origin} has={r.originHasFacility} freightType={r.freightType} />
                   {atOrigin(r) && isWaiting(r) && (
                     <Badge size="xs" color="edr-green" variant="light">
                       train here
@@ -105,7 +118,7 @@ function Rows({ rows }: { rows: IntercityRideAlongRow[] }) {
               </Table.Td>
               <Table.Td>
                 <Group gap={6} wrap="nowrap">
-                  <FacilityCell yard={r.destination} has={r.destinationHasFacility} />
+                  <FacilityCell yard={r.destination} has={r.destinationHasFacility} freightType={r.freightType} />
                   {atDestination(r) && isRiding(r) && (
                     <Badge size="xs" color="edr-green" variant="light">
                       train here
@@ -215,7 +228,7 @@ export default function IntercityPage() {
             <Stat icon={<Warehouse size={18} />} label="Completed" value={done.length} />
             <Stat
               icon={<AlertTriangle size={18} />}
-              label="No facility"
+              label="Cannot handle"
               value={blocked.length}
               color={blocked.length > 0 ? "red" : undefined}
             />
@@ -229,8 +242,9 @@ export default function IntercityPage() {
               title={`${blocked.length} booking${blocked.length === 1 ? "" : "s"} cannot be handled`}
               mb="md"
             >
-              Their origin or destination yard has no load/unload facility. Mark the yard as
-              a facility in Configuration → Yards, or the cargo can never be worked there.
+              Their origin or destination yard cannot handle that cargo — no facility, or no
+              equipment for it. Containers need Indode, Modjo or Dire Dawa; bulk is handled at
+              any facility. Adjust the yard in Configuration → Yards.
             </Alert>
           )}
 
diff --git a/apps/edr-freight-web/backoffice/src/services/api.ts b/apps/edr-freight-web/backoffice/src/services/api.ts
index fe323a472..6c6245ee6 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -193,6 +193,7 @@ import {
   type ScheduleConsist,
   type TrainComposition,
   type UpdateTrainDetailsPayload,
+  type UsedTrainNumbers,
 } from "./trainBuilder.service";
 import { trainSchedulingService } from "./trainScheduling.service";
 import { wagonTypesService, type WagonType } from "./wagon-types.service";
@@ -1825,6 +1826,14 @@ export const api = {
       ({ id }) => QUERY_KEYS.TRAIN_BUILDER.composition(id),
     ),
 
+    // Key derives to ["train-builder", "usedTrainNumbers"], so the shared
+    // TRAIN_BUILDER.ROOT invalidation refreshes it after every build/edit.
+    usedTrainNumbers: endpoint<void, UsedTrainNumbers>(
+      "train-builder",
+      "usedTrainNumbers",
+      () => trainBuilderService.usedTrainNumbers().then((r) => r.data),
+    ),
+
     build: endpoint<BuildTrainPayload, TrainComposition>(
       "train-builder",
       "build",
@@ -1902,6 +1911,22 @@ export const api = {
       () => TRAIN_BUILDER_INVALIDATIONS,
     ),
 
+    deactivate: endpoint<string, TrainComposition>(
+      "train-builder",
+      "deactivate",
+      (id) => trainBuilderService.deactivate(id).then((r) => r.data),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+
+    activate: endpoint<string, TrainComposition>(
+      "train-builder",
+      "activate",
+      (id) => trainBuilderService.activate(id).then((r) => r.data),
+      undefined,
+      () => TRAIN_BUILDER_INVALIDATIONS,
+    ),
+
     disband: endpoint<string, void>(
       "train-builder",
       "disband",
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 eb027dde7..31cc1c2dc 100644
--- a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
@@ -16,6 +16,9 @@ export interface ContractListFilter {
   tradeDirection?: string;
   contractKind?: string;
   paymentCurrency?: string;
+  /** Created-at range (ISO strings, inclusive). */
+  createdFrom?: string;
+  createdTo?: string;
   /** Server-side free-text search (contract reference, company name). */
   search?: string;
   page?: number;
@@ -139,6 +142,8 @@ function buildListParams(filter?: ContractListFilter) {
     if (filter.tradeDirection) params.tradeDirection = filter.tradeDirection;
     if (filter.contractKind) params.contractKind = filter.contractKind;
     if (filter.paymentCurrency) params.paymentCurrency = filter.paymentCurrency;
+    if (filter.createdFrom) params.createdFrom = filter.createdFrom;
+    if (filter.createdTo) params.createdTo = filter.createdTo;
   }
   return params;
 }
@@ -164,8 +169,11 @@ export const contractsService = {
     };
   },
 
-  getById: async (id: string): Promise<Freight.IContract> => {
-    const response = await client.get<Freight.IContract>(C.BY_ID(id));
+  getById: async (
+    id: string,
+    opts?: { suppressErrorModal?: boolean },
+  ): Promise<Freight.IContract> => {
+    const response = await client.get<Freight.IContract>(C.BY_ID(id), opts);
     return unwrap(response.data) as Freight.IContract;
   },
 
@@ -258,8 +266,11 @@ export const contractsService = {
     };
   },
 
-  getClearance: async (id: string): Promise<Freight.ContractClearanceView> => {
-    const response = await client.get(C.CLEARANCE(id));
+  getClearance: async (
+    id: string,
+    opts?: { suppressErrorModal?: boolean },
+  ): Promise<Freight.ContractClearanceView> => {
+    const response = await client.get(C.CLEARANCE(id), opts);
     return unwrap(response.data) as Freight.ContractClearanceView;
   },
 
diff --git a/apps/edr-freight-web/backoffice/src/services/trainBuilder.service.ts b/apps/edr-freight-web/backoffice/src/services/trainBuilder.service.ts
index 083122a10..027c8295e 100644
--- a/apps/edr-freight-web/backoffice/src/services/trainBuilder.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/trainBuilder.service.ts
@@ -9,7 +9,8 @@ export type BuiltTrainStatus =
   | "SCHEDULED"
   | "IN_SERVICE"
   | "UNDER_MAINTENANCE"
-  | "OUT_OF_SERVICE";
+  | "OUT_OF_SERVICE"
+  | "DEACTIVATED";
 
 export interface YardRefLite {
   id: string;
@@ -140,6 +141,12 @@ export interface BuildTrainPayload {
   notes?: string;
 }
 
+/** Run numbers already claimed by existing (non-deleted) trains. */
+export interface UsedTrainNumbers {
+  importTrainNumbers: string[];
+  exportTrainNumbers: string[];
+}
+
 /** Edit a built train's display identity; omitted fields keep their value. */
 export interface UpdateTrainDetailsPayload {
   /** Empty string clears the name. */
@@ -261,6 +268,8 @@ export const trainBuilderService = {
   list: (filters: BuiltTrainListFilters = {}) =>
     apiClient.get<BuiltTrainListResponse>(`${BASE}${toQuery(filters)}`),
   getComposition: (id: string) => apiClient.get<TrainComposition>(`${BASE}/${id}`),
+  /** Import/export run numbers already claimed by existing trains. */
+  usedTrainNumbers: () => apiClient.get<UsedTrainNumbers>(`${BASE}/used-train-numbers`),
   build: (payload: BuildTrainPayload) => apiClient.post<TrainComposition>(BASE, payload),
   setLocomotives: (id: string, locomotiveIds: string[]) =>
     apiClient.put<TrainComposition>(`${BASE}/${id}/locomotives`, { locomotiveIds }),
@@ -279,6 +288,11 @@ export const trainBuilderService = {
     apiClient.post<TrainComposition>(`${BASE}/${id}/wagons/${wagonId}/maintenance`),
   reorderWagons: (id: string, wagonIds: string[]) =>
     apiClient.post<TrainComposition>(`${BASE}/${id}/reorder-wagons`, { wagonIds }),
+  /** Park the train indefinitely — only allowed with no active schedule. */
+  deactivate: (id: string) =>
+    apiClient.post<TrainComposition>(`${BASE}/${id}/deactivate`),
+  /** Bring a DEACTIVATED train back to AVAILABLE. */
+  activate: (id: string) => apiClient.post<TrainComposition>(`${BASE}/${id}/activate`),
   disband: (id: string) => apiClient.delete<void>(`${BASE}/${id}`),
   /** Built trains schedulable on a route (train-scheduling picker). */
   availableTrains: (routeId: string) =>
diff --git a/apps/edr-freight-web/backoffice/src/types/booking.ts b/apps/edr-freight-web/backoffice/src/types/booking.ts
index ec31e11fa..d0e92f652 100644
--- a/apps/edr-freight-web/backoffice/src/types/booking.ts
+++ b/apps/edr-freight-web/backoffice/src/types/booking.ts
@@ -79,6 +79,8 @@ export interface BookingContainerUnit {
   vgmTons: number;
   isHazardous?: boolean;
   isReefer?: boolean;
+  /** This container ships back empty after unloading (equipment return). */
+  isReturn?: boolean;
   sortOrder?: number;
 }
 
@@ -231,6 +233,8 @@ export interface BookingListRow {
   id: string;
   reference: string;
   contractReference?: string | null;
+  /** Needed to link the reference to the contract's detail page. */
+  contractId?: string | null;
   customerLabel: string;
   approvalSteps?: BookingApprovalStep[];
   status: BookingStatus;
diff --git a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
index 5d233f5c6..97f14f1d8 100644
--- a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
+++ b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
@@ -134,7 +134,11 @@ export interface TrainSchedulePreviewResponse {
   deferredBookings?: DeferredBookingRow[];
   summary: {
     totalBookings: number;
+    /** Cargo VGM only — display gross instead. */
     totalWeightTons: number;
+    /** GROSS: cargo + the tare of every wagon in the plan. */
+    grossWeightTons: number;
+    totalTareTons: number;
     wagonType: string;
     wagonsNeeded: number;
     totalLengthMeters: number;
@@ -396,23 +400,18 @@ export interface BatchBoardBookingDetail extends BatchBoardBooking {
   consolidationPartnerRef: string | null;
 }
 
-export interface BatchWindowGroup {
-  key: string;
-  label: string;
-  /** EAT calendar day as ISO `YYYY-MM-DD` (empty for the pending-contract bucket). */
-  date: string;
-  /** Human label for the day, e.g. `Thu, 05 Jun` (empty for pending-contract). */
-  dateLabel: string;
-  start: string;
-  end: string;
-  counts: {
-    allocated: number;
-    selectedForBatch: number;
-    ready: number;
-    waiting: number;
-    expired: number;
-    pendingContract: number;
-  };
+export interface BatchBoardCounts {
+  allocated: number;
+  selectedForBatch: number;
+  ready: number;
+  waiting: number;
+  expired: number;
+  pendingContract: number;
+}
+
+/** A booking bucket on the detail board (in-window vs pending-contract). */
+export interface BatchBoardBucket {
+  counts: BatchBoardCounts;
   bookings: BatchBoardBookingDetail[];
 }
 
@@ -439,8 +438,9 @@ export interface BatchBoardScheduleDetail {
   locomotive: BatchBoardSchedule["locomotive"];
   capacity: BatchBoardSchedule["capacity"];
   counts: BatchBoardSchedule["counts"];
-  windows: BatchWindowGroup[];
-  pendingContract: BatchWindowGroup;
+  /** Bookings inside the schedule's booking window (fully-executed contracts). */
+  bookings: BatchBoardBookingDetail[];
+  pendingContract: BatchBoardBucket;
   allocationViolations: string[];
 }
 
@@ -845,6 +845,8 @@ export interface CompositionUnassignedBooking {
   freightType: FreightType | null;
   priorityScore: number;
   cargoTotalWeightVgm: number;
+  /** GROSS: cargo VGM + tare of every wagon the booking occupies. */
+  grossWeightTons: number;
   status: string | null;
   schedulingStatus: SchedulingStatus | null;
   wagonsRequired: number;
diff --git a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/BookingRow.tsx b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/BookingRow.tsx
index 007fc7fe9..7abc16192 100644
--- a/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/BookingRow.tsx
+++ b/apps/edr-freight-web/portal/src/pages/MyPortalPage/components/BookingRow.tsx
@@ -10,6 +10,7 @@ import {
   bookingIsSignable,
 } from "@/pages/bookings/contract/ContractSignButton";
 import { ApproveDeliveryButton } from "@/pages/bookings/delivery/ApproveDeliveryButton";
+import { ContractReferenceLink } from "@/pages/bookings/booking-display";
 
 interface BookingRowProps {
   booking: any;
@@ -27,9 +28,15 @@ export const BookingRow = memo(function BookingRow({
   const AIcon = cfg.action.icon;
   const ap = ACTION_PROPS[cfg.action.kind];
   // Payable bookings get an inline "Pay now" that opens the payment modal
-  // instead of navigating to the detail page.
+  // instead of navigating to the detail page. A general contract is payable as
+  // soon as it's FULLY_EXECUTED (signed); a one-time booking only after it's
+  // SELECTED_FOR_BATCH — same rule as the bookings list's PrimaryAction.
+  const payableStatus =
+    booking.bookingType === "GENERAL_CONTRACT"
+      ? "FULLY_EXECUTED"
+      : "SELECTED_FOR_BATCH";
   const canPay =
-    booking.status === "SELECTED_FOR_BATCH" && booking.paymentStatus !== "PAID";
+    booking.status === payableStatus && booking.paymentStatus !== "PAID";
   // Clearance/operation steps + changes-requested resubmit can be done in place
   // via a modal on the row.
   const hasInlineAction = bookingHasInlineAction(booking);
@@ -73,6 +80,7 @@ export const BookingRow = memo(function BookingRow({
           <Text fz={15} fw={700} c="edr-text" truncate>
             {booking.reference}
           </Text>
+          <ContractReferenceLink booking={booking} />
           <Text fz={12} c="edr-muted" truncate>
             {commodity} · {origin} → {dest}
           </Text>
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 dcc455ada..a8cc43e14 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
@@ -13,7 +13,6 @@ import type { Freight } from "@edr/types";
 
 import { BookingActionModal } from "@/pages/bookings/clearance/BookingActionModal";
 import { getBookingNextAction } from "@/pages/bookings/clearance/bookingNextAction";
-import { BookingClearanceWorkflowBanner } from "@/pages/bookings/BookingClearanceWorkflowBanner";
 
 import { CardTitle, SectionCard } from "./layout";
 
@@ -65,8 +64,9 @@ export function ClearanceCard({ booking }: { booking: Freight.IBooking }) {
 
   return (
     <SectionCard>
-      <BookingClearanceWorkflowBanner booking={booking} />
-      <Group justify="space-between" align="center" mb="md" mt="md">
+      {/* 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>
         {action && (
           <Button
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 e64d50c68..983411e89 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
@@ -1,9 +1,8 @@
 import { useMemo, useState } from "react";
-import { Alert, Badge, Box, Button, Group, Stack, Text } from "@mantine/core";
+import { Alert, Box, Button, Group, Stack, Text } from "@mantine/core";
 import { useQuery } from "@tanstack/react-query";
 import {
   Building2,
-  Check,
   ClipboardList,
   Download,
   Eye,
@@ -25,7 +24,6 @@ import toast from "react-hot-toast";
 
 import { bookingsService } from "@/services/bookings.service";
 import { saveBlob } from "@/utils/download";
-import { fmtDate } from "../utils";
 import { IconSquare } from "./Documents";
 import { CardTitle, SectionCard } from "./layout";
 
@@ -150,113 +148,7 @@ function FileRow({
   );
 }
 
-// ── customs clearance progress timeline ──────────────────────────────────────
 
-const REGION_LABELS: Record<string, string> = {
-  CUST: "You",
-  ET: "GL Ethiopia",
-  DJ: "GL Djibouti",
-  OPS: "Operations",
-};
-
-function MilestoneTimeline({
-  milestones,
-}: {
-  milestones: Freight.IClearanceMilestone[];
-}) {
-  const ordered = [...milestones].sort((a, b) => a.sortOrder - b.sortOrder);
-  const currentIdx = ordered.findIndex((m) => m.status === "PENDING");
-  return (
-    <Stack gap={0}>
-      {ordered.map((m, idx) => {
-        const done = m.status === "COMPLETED";
-        const skipped = m.status === "SKIPPED";
-        const active = idx === currentIdx;
-        const last = idx === ordered.length - 1;
-        return (
-          <Group key={m.id} gap={12} align="stretch" wrap="nowrap">
-            {/* rail: circle + connector */}
-            <Box
-              style={{
-                display: "flex",
-                flexDirection: "column",
-                alignItems: "center",
-                width: 26,
-                flexShrink: 0,
-              }}
-            >
-              <Box
-                style={{
-                  width: 22,
-                  height: 22,
-                  borderRadius: 999,
-                  display: "flex",
-                  alignItems: "center",
-                  justifyContent: "center",
-                  backgroundColor: done
-                    ? "#0EA371"
-                    : active
-                      ? "#0C1A2B"
-                      : "#EEF2F6",
-                  color: done || active ? "#fff" : "#9AA8B5",
-                  boxShadow: active ? "0 0 0 4px #D9E0E7" : undefined,
-                  fontSize: 10.5,
-                  fontWeight: 700,
-                }}
-              >
-                {done ? <Check size={13} strokeWidth={3} /> : idx + 1}
-              </Box>
-              {!last && (
-                <Box
-                  style={{
-                    width: 2,
-                    flex: 1,
-                    minHeight: 14,
-                    backgroundColor: done ? "#0EA371" : "#E1E7EE",
-                  }}
-                />
-              )}
-            </Box>
-            <Box pb={last ? 0 : 14} miw={0} flex={1}>
-              <Group gap={8} wrap="nowrap" align="center">
-                <Text
-                  fz="13.5px"
-                  fw={active ? 800 : 700}
-                  c={done || active ? "#10202F" : "#9AA8B5"}
-                  td={skipped ? "line-through" : undefined}
-                  truncate
-                >
-                  {m.milestoneLabel}
-                </Text>
-                {m.ownerRegion && REGION_LABELS[m.ownerRegion] && (
-                  <Badge
-                    size="xs"
-                    variant="light"
-                    color={m.ownerRegion === "CUST" ? "orange" : "gray"}
-                    radius="sm"
-                    tt="none"
-                  >
-                    {REGION_LABELS[m.ownerRegion]}
-                  </Badge>
-                )}
-              </Group>
-              <Text fz="11.5px" c="#9AA8B5" mt={1}>
-                {skipped
-                  ? "Skipped"
-                  : done
-                    ? `Completed${m.triggeredAt ? ` · ${fmtDate(m.triggeredAt)}` : ""}`
-                    : active
-                      ? "Current step"
-                      : "Upcoming"}
-                {m.note ? ` · ${m.note}` : ""}
-              </Text>
-            </Box>
-          </Group>
-        );
-      })}
-    </Stack>
-  );
-}
 
 // ── contract & profile document grouping ─────────────────────────────────────
 
@@ -458,18 +350,8 @@ export function DocumentsTab({ booking }: { booking: Freight.IBooking }) {
         </SectionCard>
       )}
 
-      {/* ── customs progress (Path B phased clearance) ──────────────────── */}
-      {(clearance?.milestones?.length ?? 0) > 0 && (
-        <SectionCard>
-          <CardTitle>Customs clearance progress</CardTitle>
-          <Text fz="12.5px" c="dimmed" mt={4} mb="md">
-            Every customs step for this shipment — completed steps are ticked,
-            the highlighted one is where it currently stands.
-          </Text>
-          <MilestoneTimeline milestones={clearance!.milestones!} />
-        </SectionCard>
-      )}
-
+      {/* Customs progress lives in the unified journey wizard at the top of
+          the page (StatusHero → JourneyWizard) — no duplicate timeline here. */}
       {(clearance?.workflowFiles?.length ?? 0) > 0 && (
         <SectionCard>
           <CardTitle>Customs documents</CardTitle>
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/JourneyWizard.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/JourneyWizard.tsx
new file mode 100644
index 000000000..6eabb83ad
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/JourneyWizard.tsx
@@ -0,0 +1,211 @@
+import { Badge, Box, Text } from "@mantine/core";
+import { Check } from "lucide-react";
+
+import type { Freight } from "@edr/types";
+
+import {
+  CONTRACT_PROGRESS_STAGES,
+  PROGRESS_STAGES,
+  resolveContractStage,
+  resolveStage,
+} from "../constants";
+import { isNegative } from "../utils";
+
+type StepState = "done" | "active" | "idle" | "skipped";
+
+interface JourneyStep {
+  key: string;
+  label: string;
+  state: StepState;
+  /** Milestone owner region (customs flow only) — rendered as a tiny badge. */
+  owner?: string;
+}
+
+const OWNER_LABELS: Record<string, string> = {
+  CUST: "You",
+  ET: "GL Ethiopia",
+  DJ: "GL Djibouti",
+  OPS: "Operations",
+};
+
+/**
+ * The single source for the booking-journey wizard steps.
+ *
+ * Customs (Path B) bookings: the backend GL milestone catalog IS the
+ * end-to-end process — documents → review → customs declaration → duty/tax →
+ * wagon & freight payment → loading → transit → arrival → release. Those rows
+ * are rendered directly (post-booking milestones appear once GL seeds them),
+ * framed by the booking-level steps the catalog does not carry: the prepaid
+ * clearance service fee gate at the start and final delivery at the end.
+ *
+ * Non-customs bookings: the existing lifecycle stage sets (direct vs
+ * contract-drawdown) — no customs steps ever show up.
+ */
+export function buildJourneySteps(
+  booking: Freight.IBooking,
+  milestones: Freight.IClearanceMilestone[],
+): JourneyStep[] {
+  const status = booking.status as string;
+  const isCustoms = Boolean(booking.customsClearingEnabled);
+
+  if (isCustoms && milestones.length > 0) {
+    const sorted = [...milestones].sort((a, b) => a.sortOrder - b.sortOrder);
+    const firstPendingId = sorted.find((m) => m.status === "PENDING")?.id;
+    const feeActive = status === "AWAITING_CLEARANCE_PAYMENT";
+    const delivered = ["COMPLETED", "DELIVERED"].includes(status);
+
+    const steps: JourneyStep[] = [
+      { key: "booked", label: "Booking initiated", state: "done" },
+      {
+        key: "fee",
+        label: "Clearance fee paid",
+        state: feeActive ? "active" : "done",
+        owner: "CUST",
+      },
+      ...sorted.map<JourneyStep>((m) => ({
+        key: m.id,
+        label: m.milestoneLabel,
+        owner: m.ownerRegion ?? undefined,
+        state:
+          m.status === "COMPLETED"
+            ? "done"
+            : m.status === "SKIPPED"
+              ? "skipped"
+              : !feeActive && m.id === firstPendingId
+                ? "active"
+                : "idle",
+      })),
+      { key: "delivered", label: "Delivered", state: delivered ? "done" : "idle" },
+    ];
+    // Every known milestone is done but the booking hasn't closed yet — the
+    // delivery step is what's in progress.
+    if (!feeActive && !firstPendingId && !delivered) {
+      steps[steps.length - 1].state = "active";
+    }
+    return steps;
+  }
+
+  const contractFlow = Boolean(booking.contractId) && !isNegative(status);
+  const stages = contractFlow ? CONTRACT_PROGRESS_STAGES : PROGRESS_STAGES;
+  const current = contractFlow
+    ? resolveContractStage(booking)
+    : resolveStage(booking);
+  return stages.map((s, idx) => ({
+    key: s.label,
+    label: s.label,
+    state: idx < current ? "done" : idx === current ? "active" : "idle",
+  }));
+}
+
+/**
+ * One large wizard for the whole booking journey. Steps flow left→right and
+ * wrap onto the next row when the process is long (customs imports run ~20
+ * steps → 2–3 rows) — no sideways scrolling, everything visible at once.
+ */
+export function JourneyWizard({
+  booking,
+  milestones = [],
+}: {
+  booking: Freight.IBooking;
+  milestones?: Freight.IClearanceMilestone[];
+}) {
+  const steps = buildJourneySteps(booking, milestones);
+  const last = steps.length - 1;
+
+  return (
+    <Box
+      style={{
+        display: "grid",
+        gridTemplateColumns: "repeat(auto-fill, minmax(104px, 1fr))",
+        rowGap: 22,
+      }}
+    >
+      {steps.map((s, idx) => {
+        const done = s.state === "done";
+        const active = s.state === "active";
+        const skipped = s.state === "skipped";
+        // A connector segment turns green once the step to its left completed
+        // (skipped steps pass progress through).
+        const prev = idx > 0 ? steps[idx - 1] : undefined;
+        const leftOn =
+          !!prev && (prev.state === "done" || prev.state === "skipped");
+        const rightOn = done || skipped;
+        const ownerLabel = s.owner ? OWNER_LABELS[s.owner] : undefined;
+
+        return (
+          <Box key={s.key} miw={0}>
+            {/* rail: left connector · circle · right connector */}
+            <Box style={{ display: "flex", alignItems: "center" }}>
+              <Box
+                style={{
+                  height: 3,
+                  flex: 1,
+                  borderRadius: 999,
+                  backgroundColor:
+                    idx === 0 ? "transparent" : leftOn ? "#0EA371" : "#E1E7EE",
+                }}
+              />
+              <Box
+                style={{
+                  width: 26,
+                  height: 26,
+                  borderRadius: 999,
+                  display: "flex",
+                  alignItems: "center",
+                  justifyContent: "center",
+                  flexShrink: 0,
+                  fontSize: 11,
+                  fontWeight: 700,
+                  backgroundColor: done
+                    ? "#0EA371"
+                    : active
+                      ? "#0C1A2B"
+                      : "#EEF2F6",
+                  color: done || active ? "#fff" : "#9AA8B5",
+                  border: done || active ? undefined : "1px solid #E1E7EE",
+                  boxShadow: active ? "0 0 0 4px #D9E0E7" : undefined,
+                }}
+              >
+                {done ? <Check size={14} strokeWidth={3} /> : idx + 1}
+              </Box>
+              <Box
+                style={{
+                  height: 3,
+                  flex: 1,
+                  borderRadius: 999,
+                  backgroundColor:
+                    idx === last ? "transparent" : rightOn ? "#0EA371" : "#E1E7EE",
+                }}
+              />
+            </Box>
+            {/* label (+ owner badge) centered under the circle */}
+            <Box mt={7} px={4} style={{ textAlign: "center" }}>
+              <Text
+                fz="11.5px"
+                fw={active ? 800 : 700}
+                lh={1.25}
+                c={done || active ? "#10202F" : "#9AA8B5"}
+                td={skipped ? "line-through" : undefined}
+                lineClamp={2}
+              >
+                {s.label}
+              </Text>
+              {ownerLabel && (
+                <Badge
+                  size="xs"
+                  variant="light"
+                  color={s.owner === "CUST" ? "orange" : "gray"}
+                  radius="sm"
+                  tt="none"
+                  mt={3}
+                >
+                  {ownerLabel}
+                </Badge>
+              )}
+            </Box>
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/PageHeader.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/PageHeader.tsx
index b5494ab9d..455b71a69 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/PageHeader.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/PageHeader.tsx
@@ -13,7 +13,10 @@ import type { ReactNode } from "react";
 
 import type { Freight } from "@edr/types";
 
-import { bookingStatusLabel } from "@/pages/bookings/booking-display";
+import {
+  bookingStatusLabel,
+  ContractReferenceLink,
+} from "@/pages/bookings/booking-display";
 
 import { bookingSubtitle, isDraftLike, isNegative } from "../utils";
 
@@ -50,9 +53,12 @@ export function PageHeader({
     <Group justify="space-between" align="flex-start" wrap="wrap" gap="md">
       <Stack gap={8} miw={0}>
         <Group gap={12} align="center" wrap="wrap">
-          <Text fz="26px" fw={800} c="#10202F">
-            {booking.reference}
-          </Text>
+          <Stack gap={2} miw={0}>
+            <Text fz="26px" fw={800} c="#10202F">
+              {booking.reference}
+            </Text>
+            <ContractReferenceLink booking={booking} />
+          </Stack>
 
           <span
             className="inline-flex items-center gap-[7px] rounded-full px-3 py-1.5 text-xs font-bold"
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ShipmentTrackingCard.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ShipmentTrackingCard.tsx
index 980890e28..adb6cd459 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ShipmentTrackingCard.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/ShipmentTrackingCard.tsx
@@ -1,31 +1,16 @@
-import { useMemo, useState } from "react";
+import { useState } from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
-import {
-  Badge,
-  Box,
-  Button,
-  FileButton,
-  Group,
-  Stack,
-  Text,
-  ThemeIcon,
-} from "@mantine/core";
-import { Check, Circle, Clock, Receipt, Upload } from "lucide-react";
-import type { Freight } from "@edr/types";
+import { Box, Button, FileButton, Group, Text } from "@mantine/core";
+import { Receipt, Upload } from "lucide-react";
 
 import { contractsService } from "@/services/contracts.service";
 import { SectionCard, CardTitle } from "./layout";
 
-const RISK_COLOR: Record<Freight.CustomsRiskLevel, string> = {
-  GREEN: "green",
-  YELLOW: "yellow",
-  RED: "red",
-};
-
 /**
- * Read-only shipment tracking for the customer (Path B). Shows the GL milestone
- * progression and, when GL has advised duty/tax but the slip is not yet paid,
- * surfaces a payment-slip upload — the only customer action in this phase.
+ * Customs (Path B) duty/tax panel: when GL has advised duty/tax but the slip is
+ * not yet paid, surfaces the payment-slip upload — the customer's only action
+ * in this phase. The milestone progression itself is rendered by the unified
+ * journey wizard at the top of the page.
  */
 export function ShipmentTrackingCard({ bookingId }: { bookingId: string }) {
   const qc = useQueryClient();
@@ -44,12 +29,6 @@ export function ShipmentTrackingCard({ bookingId }: { bookingId: string }) {
     },
   });
 
-  const sorted = useMemo(
-    () => [...milestones].sort((a, b) => a.sortOrder - b.sortOrder),
-    [milestones],
-  );
-  const nextPending = sorted.find((m) => m.status === "PENDING");
-
   const dutyAdvised = milestones.find(
     (m) => m.milestoneCode === "DUTY_TAXES_ADVISED",
   );
@@ -57,11 +36,14 @@ export function ShipmentTrackingCard({ bookingId }: { bookingId: string }) {
   const needsDutySlip =
     dutyAdvised?.status === "COMPLETED" && dutyPaid?.status !== "COMPLETED";
 
-  if (sorted.length === 0) return null;
+  // The milestone progression itself lives in the unified journey wizard at
+  // the top of the page — this card only surfaces the customer's one action
+  // in the customs phase: uploading the duty/tax payment slip.
+  if (!needsDutySlip) return null;
 
   return (
     <SectionCard>
-      <CardTitle>Shipment tracking</CardTitle>
+      <CardTitle>Duty &amp; tax payment</CardTitle>
 
       {needsDutySlip ? (
         <Box
@@ -115,63 +97,6 @@ export function ShipmentTrackingCard({ bookingId }: { bookingId: string }) {
           </Group>
         </Box>
       ) : null}
-
-      <Stack gap={0} mt="md">
-        {sorted.map((m, index) => {
-          const isLast = index === sorted.length - 1;
-          const isNext = nextPending?.id === m.id;
-          const Icon =
-            m.status === "COMPLETED" ? Check : isNext ? Clock : Circle;
-          const risk =
-            m.milestoneCode === "RISK_ASSIGNED"
-              ? m.metadata?.riskLevel
-              : undefined;
-
-          return (
-            <Group key={m.id} gap="sm" wrap="nowrap" align="flex-start">
-              <Stack gap={0} align="center" style={{ flexShrink: 0 }}>
-                <ThemeIcon
-                  variant={m.status === "COMPLETED" ? "filled" : "light"}
-                  color={isNext ? "edr-green" : "gray"}
-                  radius="xl"
-                  size={26}
-                >
-                  <Icon size={13} strokeWidth={2.2} />
-                </ThemeIcon>
-                {!isLast && (
-                  <Box
-                    style={{
-                      width: 2,
-                      flex: 1,
-                      minHeight: 22,
-                      background:
-                        m.status === "COMPLETED"
-                          ? "var(--mantine-color-edr-green-4)"
-                          : "var(--mantine-color-gray-2)",
-                    }}
-                  />
-                )}
-              </Stack>
-              <Box pb={isLast ? 0 : "sm"} style={{ flex: 1, minWidth: 0 }}>
-                <Group gap={8} wrap="nowrap">
-                  <Text
-                    fz="sm"
-                    fw={m.status === "COMPLETED" ? 600 : 500}
-                    c={m.status === "COMPLETED" ? undefined : "dimmed"}
-                  >
-                    {m.milestoneLabel}
-                  </Text>
-                  {risk ? (
-                    <Badge size="xs" color={RISK_COLOR[risk]} variant="filled">
-                      {risk}
-                    </Badge>
-                  ) : null}
-                </Group>
-              </Box>
-            </Group>
-          );
-        })}
-      </Stack>
     </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 b9d7ee8e8..c702329d1 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
@@ -1,18 +1,20 @@
 import { Box, Group, Text } from "@mantine/core";
-import { Check, MoveRight } from "lucide-react";
+import { useQuery } from "@tanstack/react-query";
+import { MoveRight } from "lucide-react";
 
 import type { Freight } from "@edr/types";
 
+import { contractsService } from "@/services/contracts.service";
+
 import {
   ARRIVAL_STAGE,
   CONTRACT_ARRIVAL_STAGE,
-  CONTRACT_PROGRESS_STAGES,
-  PROGRESS_STAGES,
   STATUS_MAP,
   resolveContractStage,
   resolveStage,
 } from "../constants";
 import { fmtDate, isDraftLike, isNegative, yardLabel } from "../utils";
+import { JourneyWizard } from "./JourneyWizard";
 import { SectionCard } from "./layout";
 
 /** Origin → destination strip rendered above the progress tracker. */
@@ -73,13 +75,17 @@ export function StatusHero({
   children?: React.ReactNode;
 }) {
   const status = booking.status;
+  // Customs (Path B) bookings render the GL milestone rows inside the unified
+  // wizard. Same query key the duty-slip panel uses, so the cache is shared.
+  const { data: milestones = [] } = useQuery({
+    queryKey: ["booking-milestones", booking.id],
+    queryFn: () => contractsService.getBookingMilestones(booking.id),
+    enabled: Boolean(booking.id) && Boolean(booking.customsClearingEnabled),
+  });
   // Contract-drawdown bookings (initiated under a contract) follow a dedicated
   // wizard — initiated → submitted → accepted → payment → … — instead of the
   // direct booking's Request/Approval/Contract stages.
   const isContractDrawdown = Boolean(booking.contractId) && !isNegative(status);
-  const stages = isContractDrawdown
-    ? CONTRACT_PROGRESS_STAGES
-    : PROGRESS_STAGES;
   const arrivalStage = isContractDrawdown
     ? CONTRACT_ARRIVAL_STAGE
     : ARRIVAL_STAGE;
@@ -157,128 +163,8 @@ export function StatusHero({
       {!negative && <RouteStrip booking={booking} />}
 
       {children ?? (
-        <ProgressTracker
-          current={stage}
-          stages={stages}
-          tone={draft ? "ink" : "green"}
-          negative={negative}
-        />
+        <JourneyWizard booking={booking} milestones={milestones} />
       )}
     </SectionCard>
   );
 }
-
-function ProgressTracker({
-  current,
-  stages = PROGRESS_STAGES,
-  tone = "green",
-}: {
-  current: number;
-  /** Which stage set to render — direct or contract-drawdown. */
-  stages?: typeof PROGRESS_STAGES;
-  tone?: "green" | "ink";
-  negative?: boolean;
-}) {
-  const last = stages.length - 1;
-  const activeFill = tone === "ink" ? "#0C1A2B" : "#0EA371";
-  const activeRing = tone === "ink" ? "#D9E0E7" : "#BFE8D4";
-
-  return (
-    /* Scrollable on mobile so the stages never overflow */
-    <Box
-      className="overflow-x-auto pt-2"
-      style={
-        {
-          scrollbarWidth: "none",
-          WebkitOverflowScrolling: "touch",
-        } as React.CSSProperties
-      }
-    >
-      {/* ~84px per stage keeps 2-word labels readable; the box scrolls on mobile. */}
-      <div
-        className="flex items-start"
-        style={{ minWidth: Math.max(640, stages.length * 84) }}
-      >
-        {stages.map((stage, idx) => {
-          const state =
-            idx < current ? "done" : idx === current ? "active" : "idle";
-          const Icon = stage.icon;
-          const reachedLeft = current >= idx && current >= 0;
-          const reachedRight = current > idx && current >= 0;
-
-          const circleBg =
-            state === "idle"
-              ? "#EEF2F6"
-              : state === "active"
-                ? activeFill
-                : "#0EA371";
-          const circleBorder =
-            state === "idle" ? "1px solid #E1E7EE" : undefined;
-          const circleShadow =
-            state === "active" ? `0 0 0 4px ${activeRing}` : undefined;
-
-          return (
-            <div
-              key={stage.label}
-              className="flex flex-1 flex-col items-center"
-            >
-              <div className="flex w-full items-center">
-                {/* left connector */}
-                <div
-                  className="flex-1 rounded-full"
-                  style={{
-                    height: 3,
-                    background:
-                      idx === 0
-                        ? "transparent"
-                        : reachedLeft
-                          ? "#0EA371"
-                          : "#E1E7EE",
-                  }}
-                />
-                {/* stage circle */}
-                <div
-                  className="flex items-center justify-center mb-2 rounded-full shrink-0"
-                  style={{
-                    width: 32,
-                    height: 32,
-                    backgroundColor: circleBg,
-                    border: circleBorder,
-                    boxShadow: circleShadow,
-                  }}
-                >
-                  {state === "done" ? (
-                    <Check size={16} color="#fff" />
-                  ) : state === "active" ? (
-                    <Icon size={16} color="#fff" />
-                  ) : null}
-                </div>
-                {/* right connector */}
-                <div
-                  className="flex-1 rounded-full"
-                  style={{
-                    height: 3,
-                    background:
-                      idx === last
-                        ? "transparent"
-                        : reachedRight
-                          ? "#0EA371"
-                          : "#E1E7EE",
-                  }}
-                />
-              </div>
-              <Text
-                fz="14px"
-                fw={700}
-                ta="center"
-                c={state === "idle" ? "#9AA8B5" : "#10202F"}
-              >
-                {stage.label}
-              </Text>
-            </div>
-          );
-        })}
-      </div>
-    </Box>
-  );
-}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx
index d2f944690..3f20c79e4 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingsListPage.tsx
@@ -37,6 +37,11 @@ import { ShipmentTrackingModal } from "./tracking/ShipmentTrackingModal";
 import { PayNowButton } from "./payments/PayNowButton";
 import { BookingActionButton } from "./clearance/BookingActionButton";
 import { bookingHasInlineAction } from "./clearance/bookingNextAction";
+import {
+  ContractSignButton,
+  bookingIsSignable,
+} from "./contract/ContractSignButton";
+import { ApproveDeliveryButton } from "./delivery/ApproveDeliveryButton";
 import {
   BookingStatusBadge as StatusBadge,
   BookingTypeBadge,
@@ -54,6 +59,7 @@ import {
   type ColumnDef,
   usePagination,
 } from "@edr/ui-common";
+import "./bookings-table.css";
 
 // Bookings that have left (or are leaving) the yard can be tracked live.
 const TRACKABLE_STATUSES = new Set([
@@ -200,6 +206,14 @@ function PrimaryAction({
   if (status === payableStatus && booking.paymentStatus !== "PAID") {
     return <PayNowButton booking={booking} />;
   }
+  // Contract ready for the customer's signature → full-page contract viewer.
+  if (bookingIsSignable(booking)) {
+    return <ContractSignButton booking={booking} size="xs" />;
+  }
+  // Delivered cargo with a handover awaiting the customer's signature.
+  if (booking.handoverAwaitingSignature) {
+    return <ApproveDeliveryButton bookingId={id} size="xs" stopPropagation />;
+  }
   return (
     <Button
       size="xs"
@@ -886,7 +900,7 @@ export default function BookingsListPage() {
                 manualPagination: true,
                 pageCount,
               }}
-              containerClassName="border-0 shadow-none rounded-none"
+              containerClassName="edr-bookings-table border-0 shadow-none rounded-none"
               footer={DataTableFooter}
             />
           )}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx b/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx
index 780099d1f..24d9d421e 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/booking-display.tsx
@@ -1,4 +1,5 @@
 import { Badge, Box, Group, Text } from "@mantine/core";
+import { Link } from "react-router-dom";
 import type { Freight } from "@edr/types";
 
 import { STATUS_CONFIG } from "@/pages/MyPortalPage/constants";
@@ -9,6 +10,40 @@ import { STATUS_CONFIG } from "@/pages/MyPortalPage/constants";
  * and detail page render type/freight/mode/payment consistently.
  */
 
+/**
+ * The parent contract's reference, rendered small under a booking reference and
+ * linking to that contract's detail page.
+ *
+ * Renders nothing when either field is missing: `contractId` is nullable on the
+ * booking, and only the bookings list/detail endpoints join `contractReference`
+ * — other endpoints (warehouse, fleet, payments) return booking rows without it,
+ * and a link with no id would be a dead one.
+ *
+ * `stopPropagation` matters: booking rows are click-to-navigate, so without it a
+ * click here would race the row handler and land on the booking instead.
+ */
+export function ContractReferenceLink({
+  booking,
+}: {
+  booking: Pick<Freight.IBooking, "contractId" | "contractReference">;
+}) {
+  if (!booking.contractId || !booking.contractReference) return null;
+
+  return (
+    <Text
+      component={Link}
+      to={`/contracts/${booking.contractId}`}
+      onClick={(e) => e.stopPropagation()}
+      fz={11}
+      c="edr-muted"
+      truncate
+      style={{ display: "block", textDecoration: "underline" }}
+    >
+      {booking.contractReference}
+    </Text>
+  );
+}
+
 /** Title-case an unmapped enum as a readable fallback ("FOO_BAR" → "Foo Bar"). */
 export function titleCaseStatus(status: string): string {
   return status
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/bookings-table.css b/apps/edr-freight-web/portal/src/pages/bookings/bookings-table.css
new file mode 100644
index 000000000..043bc58fc
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/bookings/bookings-table.css
@@ -0,0 +1,84 @@
+/*
+ * Scoped to .edr-bookings-table — the DataTable container div on the bookings
+ * list only; no other DataTable is affected. Mirrors contracts-table.css:
+ * content-sized columns with a 40px floor, horizontal scroll when the table
+ * outgrows the card, and a sticky shadowed action column.
+ */
+.edr-bookings-table {
+  overflow-x: auto;
+}
+
+/*
+ * width: max-content — the table is exactly as wide as its columns' content
+ * needs, never squeezed to fit the viewport; the container scrolls instead.
+ * min-width: 100% keeps it filling the card when content is narrow.
+ */
+.edr-bookings-table table {
+  table-layout: auto;
+  width: max-content;
+  min-width: 100%;
+}
+
+.edr-bookings-table th,
+.edr-bookings-table td {
+  min-width: 40px;
+}
+
+/*
+ * Mantine Badge caps itself at max-width: 100%; inside an auto-layout table
+ * cell that resolves against min-content and clips the label. Let badges size
+ * to their text so the column grows to fit them.
+ */
+.edr-bookings-table .mantine-Badge-root {
+  max-width: none;
+}
+
+/*
+ * Full-width rows (error / empty state) span every column via colspan — leave
+ * their wrapping alone.
+ */
+.edr-bookings-table th,
+.edr-bookings-table td:not([colspan]) {
+  white-space: nowrap;
+}
+
+/* Sticky header row. */
+.edr-bookings-table thead th {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+}
+
+/*
+ * Sticky action column, shrunk to its content. The width overrides the inline
+ * width DataTable stamps from tanstack's default column size — hence
+ * !important. `:not([colspan])` keeps the full-width error/empty rows out.
+ */
+.edr-bookings-table th:last-child,
+.edr-bookings-table td:last-child:not([colspan]) {
+  width: 1% !important;
+  position: sticky;
+  right: 0;
+  box-shadow: -12px 0 16px -6px rgba(16, 32, 47, 0.3);
+}
+
+/*
+ * Sticky cells sit above the scrolling ones, so they need their own opaque
+ * background or the columns underneath show through.
+ */
+.edr-bookings-table td:last-child:not([colspan]) {
+  /* Very light blue-grey tint sets the action column apart from the rows. */
+  background: #f5f8fb;
+  z-index: 2;
+}
+
+/* Row hover uses the tailwind `hover:bg-accent` class on the <tr>. */
+.edr-bookings-table tbody tr:hover td:last-child:not([colspan]) {
+  background: var(--accent, #f4fbf8);
+}
+
+/* Header cell is sticky on both axes — it must outrank the body's sticky column. */
+.edr-bookings-table th:last-child {
+  background: #f4f7fa;
+  z-index: 3;
+}
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/LocationPicker.tsx b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/LocationPicker.tsx
index b2f14b16f..6a53be5cc 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/LocationPicker.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/new-booking-form/LocationPicker.tsx
@@ -409,7 +409,11 @@ function LocationPickerInline({
   const geocoder = useGeocoder();
   const places = usePlacesSearch();
   const placesLib = useMapsLibrary("places");
-  const [query, setQuery] = useState("");
+  // `null` means "not editing" (show the saved address); any string — including
+  // "" after the user clears the field — is live edit state. A plain `query ||
+  // value.address` fallback would snap the saved address back the moment the
+  // user cleared the input, making it impossible to retype the location.
+  const [query, setQuery] = useState<string | null>(null);
   const [results, setResults] = useState<PlacePrediction[]>([]);
   const [searching, setSearching] = useState(false);
   const [resolving, setResolving] = useState(false);
@@ -430,7 +434,7 @@ function LocationPickerInline({
   // than one per keystroke. While it runs, the input shows a spinner; the
   // dropdown itself only appears once there are predictions to show.
   useEffect(() => {
-    const q = query.trim();
+    const q = (query ?? "").trim();
     if (q.length < MIN_QUERY_LEN) {
       setResults([]);
       setSearching(false);
@@ -469,7 +473,7 @@ function LocationPickerInline({
     async (prediction: PlacePrediction) => {
       // Clear the query/results immediately so the pending debounce can't fire
       // a search for the picked address and pop the dropdown back open.
-      setQuery("");
+      setQuery(null);
       setResults([]);
       // Predictions carry no coordinates — resolve them now via Place Details.
       if (!places) return;
@@ -498,6 +502,9 @@ function LocationPickerInline({
   const handlePin = useCallback(
     async (lat: number, lng: number) => {
       // Show the pin immediately; fill the address once reverse geocoding lands.
+      // Leave edit mode so the input reflects the reverse-geocoded address
+      // instead of whatever half-typed query the user abandoned for the map.
+      setQuery(null);
       onChange({ address: value.address, lat, lng });
       if (!geocoder) return;
       // Mark any in-flight reverse lookup stale — only the latest pin counts.
@@ -525,7 +532,7 @@ function LocationPickerInline({
     [handlePin],
   );
 
-  const inputValue = query || value.address;
+  const inputValue = query ?? value.address;
   const center = hasPin
     ? { lat: value.lat as number, lng: value.lng as number }
     : DEFAULT_CENTER;
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 21594c5ca..f03f99b01 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractDetailPage.tsx
@@ -141,9 +141,13 @@ const BUSINESS_LICENSE_DOC_CODES = new Set([
 // documents" rather than the clearance set.
 const PROFILE_DOC_CODES = new Set([
   "tin_certificate",
+  "tin",
   "national_id",
   "national_id_passport",
   "passport",
+  // The seeded company-onboarding setting stores the national ID field with the
+  // bare code "id" — without this the doc lands in the clearance catch-all.
+  "id",
 ]);
 
 interface DocGroup {
@@ -164,23 +168,44 @@ interface DocGroup {
  */
 function groupContractDocuments(
   files: ContractFile[],
-  { includeClearance = true }: { includeClearance?: boolean } = {},
+  {
+    includeClearance = true,
+    clearanceKeys,
+  }: { includeClearance?: boolean; clearanceKeys?: Set<string> } = {},
 ): DocGroup[] {
   const businessLicense: ContractFile[] = [];
   const profile: ContractFile[] = [];
   const clearance: ContractFile[] = [];
+  const other: ContractFile[] = [];
+
+  // A file belongs to the clearance set when its code matches a clearance
+  // upload field (multi-file uploads append `_<n>`), an ad-hoc `custom_*` doc,
+  // or a known GL workflow artifact. Without a key list (clearance view not
+  // loaded for this status) everything unclassified stays under clearance —
+  // the pre-existing catch-all behaviour.
+  const isClearanceCode = (code: string): boolean => {
+    if (code.startsWith("custom_")) return true;
+    if (clearanceWorkflowFileLabel(code)) return true;
+    if (!clearanceKeys || clearanceKeys.size === 0) return true;
+    return (
+      clearanceKeys.has(code) || clearanceKeys.has(code.replace(/_\d+$/, ""))
+    );
+  };
+
   for (const f of files) {
     // The generated contract PDF lives in the contract list / home rows, not
     // here. Signature images are baked into that PDF — skip both.
     if (f.code === "contract" || f.code.startsWith("signature_")) continue;
     else if (BUSINESS_LICENSE_DOC_CODES.has(f.code)) businessLicense.push(f);
     else if (PROFILE_DOC_CODES.has(f.code)) profile.push(f);
-    else if (includeClearance) clearance.push(f);
+    else if (includeClearance && isClearanceCode(f.code)) clearance.push(f);
+    else other.push(f);
   }
   return [
-    { key: "clearance", title: "Clearance documents", files: clearance },
+    { key: "profile", title: "Company profile", files: profile },
     { key: "businessLicense", title: "Business license", files: businessLicense },
-    { key: "profile", title: "Profile documents", files: profile },
+    { key: "clearance", title: "Clearance documents", files: clearance },
+    { key: "other", title: "Other documents", files: other },
   ].filter((g) => g.files.length > 0);
 }
 
@@ -346,8 +371,13 @@ export default function ContractDetailPage() {
   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),
+    ),
   });
   const docCount = docGroups.reduce((sum, g) => sum + g.files.length, 0);
   // The generated contract PDF — surfaced via a dedicated "View contract" button
@@ -1190,21 +1220,13 @@ export default function ContractDetailPage() {
                 />
               ) : null}
 
-            <Card
-              withBorder
-              radius="lg"
-              p="lg"
-              style={{ borderColor: BORDER, boxShadow: CARD_SHADOW }}
-            >
-              <Group justify="space-between" align="center" mb="md">
-                <SectionLabel>Contract documents</SectionLabel>
-                {contract.contractGeneratedAt && (
-                  <Badge size="sm" variant="light" color="edr-green" radius="sm">
-                    Generated
-                  </Badge>
-                )}
-              </Group>
-              {docGroups.length === 0 ? (
+            {docGroups.length === 0 ? (
+              <Card
+                withBorder
+                radius="lg"
+                p="lg"
+                style={{ borderColor: BORDER, boxShadow: CARD_SHADOW }}
+              >
                 <Stack align="center" gap={10} py={48}>
                   <Box
                     style={{
@@ -1228,55 +1250,56 @@ export default function ContractDetailPage() {
                       : "The signed contract and any uploaded clearance documents will appear here."}
                   </Text>
                 </Stack>
-              ) : (
-                <Stack gap="xl">
-                  {docGroups.map((group) => {
-                    const accent = DOC_GROUP_ACCENT[group.key] ?? GREEN;
-                    const Icon = DOC_GROUP_ICON[group.key] ?? FileText;
-                    return (
-                      <Stack key={group.key} gap={10}>
-                        <Group gap={10} align="center">
-                          <Box
-                            style={{
-                              width: 28,
-                              height: 28,
-                              borderRadius: 8,
-                              display: "flex",
-                              alignItems: "center",
-                              justifyContent: "center",
-                              background: `${accent}14`,
-                              color: accent,
-                            }}
-                          >
-                            <Icon size={15} />
-                          </Box>
-                          <Text fz={13} fw={700} style={{ color: INK }}>
-                            {group.title}
-                          </Text>
-                          <Badge
-                            size="sm"
-                            variant="light"
-                            color="gray"
-                            radius="sm"
-                          >
-                            {group.files.length}
-                          </Badge>
-                        </Group>
-                        <Stack gap={10}>
-                          {group.files.map((file) => (
-                            <DocFileRow
-                              key={file.id}
-                              file={file}
-                              onView={view}
-                            />
-                          ))}
-                        </Stack>
-                      </Stack>
-                    );
-                  })}
-                </Stack>
-              )}
-            </Card>
+              </Card>
+            ) : (
+              // One card per section — profile, business licence, clearance,
+              // other — instead of a single flat list.
+              docGroups.map((group) => {
+                const accent = DOC_GROUP_ACCENT[group.key] ?? GREEN;
+                const Icon = DOC_GROUP_ICON[group.key] ?? FileText;
+                return (
+                  <Card
+                    key={group.key}
+                    withBorder
+                    radius="lg"
+                    p="lg"
+                    style={{ borderColor: BORDER, boxShadow: CARD_SHADOW }}
+                  >
+                    <Group gap={12} align="center" mb={4}>
+                      <Box
+                        style={{
+                          width: 34,
+                          height: 34,
+                          borderRadius: 10,
+                          display: "flex",
+                          alignItems: "center",
+                          justifyContent: "center",
+                          background: `${accent}14`,
+                          color: accent,
+                          flexShrink: 0,
+                        }}
+                      >
+                        <Icon size={17} />
+                      </Box>
+                      <Text fz={14.5} fw={700} style={{ color: INK }}>
+                        {group.title}
+                      </Text>
+                      <Badge size="sm" variant="light" color="gray" radius="sm">
+                        {group.files.length}
+                      </Badge>
+                    </Group>
+                    <Text fz={12.5} c="dimmed" mb="md" ml={46}>
+                      {DOC_GROUP_DESC[group.key] ?? ""}
+                    </Text>
+                    <Stack gap={10}>
+                      {group.files.map((file) => (
+                        <DocFileRow key={file.id} file={file} onView={view} />
+                      ))}
+                    </Stack>
+                  </Card>
+                );
+              })
+            )}
             </Stack>
           </Tabs.Panel>
 
@@ -1579,16 +1602,26 @@ const KEY_FACT_ACCENT: Record<string, string> = {
   orange: "#C77F09",
 };
 
-// Per-section accent + icon for the Documents tab groups.
+// Per-section accent + icon + description for the Documents tab groups.
 const DOC_GROUP_ACCENT: Record<string, string> = {
   clearance: "#C77F09",
   businessLicense: "#0A6F4D",
   profile: "#2B6CB0",
+  other: "#64748B",
 };
 const DOC_GROUP_ICON: Record<string, LucideIcon> = {
   clearance: Upload,
   businessLicense: FileBadge,
   profile: FileText,
+  other: FileText,
+};
+const DOC_GROUP_DESC: Record<string, string> = {
+  profile:
+    "Identity and onboarding documents attached from your company profile.",
+  businessLicense: "Business and trade licences on file for this company.",
+  clearance:
+    "Documents uploaded for the customs clearance review of this contract.",
+  other: "Additional files attached to this contract.",
 };
 
 /**
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
index cdef9136e..bd447db73 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/ContractsList.tsx
@@ -50,6 +50,7 @@ import {
   StatCard,
 } from "./contract-ui";
 import { ContractStepBanner } from "./ContractStepBanner";
+import "./contracts-table.css";
 
 function primaryRoute(contract: Freight.IContract) {
   const route = contract.routes?.[0];
@@ -367,11 +368,15 @@ export default function ContractsList() {
         >
           <Box style={{ overflowX: "auto" }}>
             <Table
+              className="edr-contracts-table"
               verticalSpacing={14}
-              horizontalSpacing={20}
+              horizontalSpacing={10}
               highlightOnHover
               highlightOnHoverColor="#F4FBF8"
               styles={{
+                // Sticky positioning, z-index and wrapping live in
+                // contracts-table.css — Mantine's `styles` prop emits inline
+                // styles, which would outrank the sticky action column there.
                 th: {
                   fontSize: 11,
                   fontWeight: 700,
@@ -380,10 +385,6 @@ export default function ContractsList() {
                   color: MUTED,
                   background: "#F8FAFC",
                   borderBottom: `1px solid ${BORDER}`,
-                  whiteSpace: "nowrap",
-                  position: "sticky",
-                  top: 0,
-                  zIndex: 1,
                 },
                 tr: {
                   transition: "background-color 120ms ease",
@@ -402,6 +403,7 @@ export default function ContractsList() {
                   <Table.Th>Cargo</Table.Th>
                   <Table.Th>Route</Table.Th>
                   <Table.Th>Trade</Table.Th>
+                  <Table.Th>Customs</Table.Th>
                   <Table.Th>Currency</Table.Th>
                   <Table.Th>Created</Table.Th>
                   <Table.Th>Valid Until</Table.Th>
@@ -412,7 +414,7 @@ export default function ContractsList() {
               <Table.Tbody>
                 {isLoading && (
                   <Table.Tr>
-                    <Table.Td colSpan={11}>
+                    <Table.Td colSpan={12}>
                       <Center py={48}>
                         <Loader color="edr-green" size="sm" />
                       </Center>
@@ -422,7 +424,7 @@ export default function ContractsList() {
 
                 {!isLoading && isError && (
                   <Table.Tr>
-                    <Table.Td colSpan={11}>
+                    <Table.Td colSpan={12}>
                       <Center py={48}>
                         <Text fz={13} c="red">
                           Failed to load contracts. Please try again.
@@ -434,7 +436,7 @@ export default function ContractsList() {
 
                 {!isLoading && !isError && rows.length === 0 && (
                   <Table.Tr>
-                    <Table.Td colSpan={11}>
+                    <Table.Td colSpan={12}>
                       <Stack align="center" gap={8} py={48}>
                         <Inbox
                           size={26}
@@ -463,6 +465,9 @@ export default function ContractsList() {
                     return (
                       <Fragment key={c.id}>
                         <Table.Tr
+                          // Read by contracts-table.css to keep the sticky
+                          // action cell's opaque background in step with the row.
+                          data-expanded={isOpen ? "true" : undefined}
                           style={{
                             cursor: "pointer",
                             background: isOpen ? "#F4FBF8" : undefined,
@@ -556,6 +561,15 @@ export default function ContractsList() {
                               {tradeLabel}
                             </Text>
                           </Table.Td>
+                          <Table.Td>
+                            <Badge
+                              variant="light"
+                              color={c.customsClearingEnabled ? "edr-green" : "gray"}
+                              radius="sm"
+                            >
+                              {c.customsClearingEnabled ? "With customs" : "Without"}
+                            </Badge>
+                          </Table.Td>
                           <Table.Td>
                             <Text fz={13} style={{ color: INK }}>
                               {c.paymentCurrency ?? "—"}
@@ -608,7 +622,7 @@ export default function ContractsList() {
                         {isOpen && (
                           <Table.Tr style={{ background: "#F4FBF8" }}>
                             <Table.Td
-                              colSpan={11}
+                              colSpan={12}
                               style={{ padding: "6px 20px 18px" }}
                             >
                               <ContractStepBanner contract={c} />
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
index 67a1a9071..d060b7651 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
@@ -39,11 +39,9 @@ import {
 import useAuth from "@/hooks/useAuth";
 import {
   CONTRACT_STEPS,
-  EDIT_CONTRACT_STEPS,
   ContractFormInputValues,
   contractFormSchema,
   contractStepFields,
-  editContractStepFields,
   initialContractFormValues,
   OPERATION_TYPES,
   type ContractFormValues,
@@ -55,12 +53,6 @@ import {
   operationToTradeDirection,
 } from "./new-contract-form/helpers";
 import { contractToFormValues } from "./new-contract-form/contractToForm";
-import {
-  ContractDocsEditor,
-  documentSettingCode,
-  missingRequiredDocKeys,
-  useCompanyDocuments,
-} from "./new-contract-form/ContractDocsEditor";
 import { PROFILE_TYPE_LABELS } from "@/constants/profileMode";
 import type { ProfileTypeValue } from "@/services/companies.service";
 import { StepIndicator } from "./new-contract-form/StepIndicator";
@@ -84,8 +76,8 @@ type PriceModalMode = "submit" | "draft";
  * The contract wizard, used both to create a new contract and — in `edit` mode —
  * to continue an unsubmitted DRAFT or edit & resubmit a contract staff returned
  * with CHANGES_REQUESTED. Edit mode hydrates the form from the saved contract,
- * lets the customer change any term and replace documents, then runs the same
- * update → price → submit flow.
+ * lets the customer change any term, then runs the same update → price →
+ * submit flow. Same 3 steps as create — there is no separate documents step.
  */
 export default function NewContractPage({
   mode = "create",
@@ -105,22 +97,6 @@ export default function NewContractPage({
     ...api.contracts.get.queryOptions({ input: { id: editId ?? "" } }),
     enabled: isEdit,
   });
-  // Onboarding document requirements — used in edit mode to block resubmit until
-  // every required document is on file (existing or freshly attached).
-  const editDocSettingQuery = useQuery({
-    ...api.fileUploadSettings.getByCode.queryOptions({
-      input: {
-        code: documentSettingCode(
-          auth.company?.company?.nationality as string | null | undefined,
-        ),
-      },
-    }),
-    enabled: isEdit,
-  });
-  // Profile documents (TIN, licenses, IDs) satisfy requirements too — the API
-  // carries them onto the contract on save.
-  const companyDocs = useCompanyDocuments();
-
   // Contract creation is gated on profile approval, same as bookings.
   if (!auth.isPending && auth.company && !auth.canBook) {
     return <Navigate to="/contracts" replace />;
@@ -167,12 +143,6 @@ export default function NewContractPage({
   const [priceContractId, setPriceContractId] = useState<string | null>(
     isEdit ? (editId ?? null) : null,
   );
-  // Documents freshly attached on the review step (edit mode only). Merged into
-  // the form's `documents` map before the contract is updated.
-  const [editDocuments, setEditDocuments] = useState<
-    Record<string, File | File[] | null>
-  >({});
-  const [showDocErrors, setShowDocErrors] = useState(false);
   const [priceModalMode, setPriceModalMode] = useState<PriceModalMode | null>(
     null,
   );
@@ -311,10 +281,9 @@ export default function NewContractPage({
   const destinationYard = form.watch("destinationYard");
   const operationType = form.watch("operationType");
 
-  const visibleSteps = useMemo(
-    () => (isEdit ? EDIT_CONTRACT_STEPS : CONTRACT_STEPS),
-    [isEdit],
-  );
+  // Create and edit share the same 3 steps — documents come along automatically
+  // (company profile docs are carried onto the contract by the API on save).
+  const visibleSteps = CONTRACT_STEPS;
   const visibleStepIds = useMemo<number[]>(
     () => visibleSteps.map((s) => s.id),
     [visibleSteps],
@@ -519,25 +488,11 @@ export default function NewContractPage({
   }, [auth.company, auth.activeCompanyProfileId]);
 
   async function handleContinue() {
-    const stepFields = isEdit ? editContractStepFields : contractStepFields;
-    const fields = stepFields[step];
+    const fields = contractStepFields[step];
     if (fields.length > 0) {
       const valid = await form.trigger(fields, { shouldFocus: true });
       if (!valid) return;
     }
-    if (isEdit && step === 2 && editContract) {
-      const missing = missingRequiredDocKeys(
-        editDocSettingQuery.data,
-        editContract,
-        editDocuments,
-        companyDocs,
-      );
-      if (missing.length > 0) {
-        setShowDocErrors(true);
-        return;
-      }
-      setShowDocErrors(false);
-    }
     goToStep(1);
   }
 
@@ -565,6 +520,8 @@ export default function NewContractPage({
     const cargoScope: Freight.CreateContractCargoScopeDto[] = isContainer
       ? data.enabledContainerSizes.map((size) => ({
           containerSize: size,
+          // Required cargo description — what the containers carry.
+          cargoFreeText: data.cargoFreeText.trim() || undefined,
         }))
       : [
           {
@@ -649,26 +606,6 @@ export default function NewContractPage({
 
   const handleSubmitContract = form.handleSubmit((data) => {
     try {
-      // Edit mode: all required documents must be on file (already uploaded or
-      // freshly attached) before resubmitting, and freshly attached files are
-      // merged into the form's documents map so the update sends them.
-      if (isEdit && editContract) {
-        const missing = missingRequiredDocKeys(
-          editDocSettingQuery.data,
-          editContract,
-          editDocuments,
-          companyDocs,
-        );
-        if (missing.length > 0) {
-          setShowDocErrors(true);
-          return;
-        }
-        setShowDocErrors(false);
-        form.setValue("documents", {
-          ...(form.getValues("documents") ?? {}),
-          ...editDocuments,
-        });
-      }
       const apiPayload = buildApiPayload(data);
       persistAndPriceMutation.mutate({
         payload: apiPayload,
@@ -724,8 +661,8 @@ export default function NewContractPage({
           <Text size="sm" c="edr-muted" mt={4}>
             {isEdit
               ? editContract?.status === "CHANGES_REQUESTED"
-                ? "Update your contract details and documents, then resubmit it for EDR staff review."
-                : "Update your draft contract details and documents, then submit it for EDR staff review."
+                ? "Update your contract details, then resubmit it for EDR staff review."
+                : "Update your draft contract details, then submit it for EDR staff review."
               : "Define your freight contract — scope, routes, and unit rates. Book shipments against it after signing."}
           </Text>
         </Box>
@@ -769,12 +706,12 @@ export default function NewContractPage({
                     {editContract.latestChangeRequestNote}
                   </Text>
                   <Text size="sm" c="dimmed" mt={2}>
-                    Update the details or documents below, then resubmit the
-                    contract for review.
+                    Update the details below, then resubmit the contract for
+                    review.
                   </Text>
                 </Stack>
               ) : (
-                "Update any contract detail or document that needs to change, then resubmit the contract for review."
+                "Update any contract detail that needs to change, then resubmit the contract for review."
               )}
             </Alert>
           )}
@@ -843,35 +780,8 @@ export default function NewContractPage({
             </StepCard>
           )}
 
-          {/* Step 2 (edit) — Documents. */}
-          {step === 2 && isEdit && editContract && (
-            <StepCard>
-              <StepHeader
-                title="Contract Documents"
-                description="Upload or replace the documents required for this contract before resubmitting."
-              />
-              <ContractDocsEditor
-                contract={editContract}
-                value={editDocuments}
-                onChange={setEditDocuments}
-                errors={
-                  showDocErrors
-                    ? Object.fromEntries(
-                      missingRequiredDocKeys(
-                        editDocSettingQuery.data,
-                        editContract,
-                        editDocuments,
-                        companyDocs,
-                      ).map((k) => [k, "Required"]),
-                    )
-                    : {}
-                }
-              />
-            </StepCard>
-          )}
-
-          {/* Step 2 (create) / Step 3 (edit) — Review & Submit. */}
-          {((step === 2 && !isEdit) || (step === 3 && isEdit)) && (
+          {/* Step 2 — Review & Submit. */}
+          {step === 2 && (
             <Step8Review
               form={form}
               setStep={setStep}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
index ea83c8163..f367f4e15 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
@@ -59,8 +59,6 @@ import {
   StepCard,
   StepHeader,
   StepLabel,
-  ToggleRow,
-  UnitCountToggles,
   fieldStyles,
 } from "./new-contract-form/shared";
 import { formatRateUnit } from "./new-contract-form/unit-rates";
@@ -362,6 +360,11 @@ function NewShipmentBookingForm({
                   containerNumber: u.containerNumber,
                   sealNumber: u.sealNumber || undefined,
                   vgmTons: Number(u.vgmTons),
+                  // Per-container handling — the server rolls these up into the
+                  // line counts and bills each surcharge on the ticked containers.
+                  isHazardous: Boolean(u.isHazardous),
+                  isReefer: Boolean(u.isReefer),
+                  ...(withReturnService ? { isReturn: Boolean(u.isReturn) } : {}),
                 })),
               })),
           }
@@ -1133,7 +1136,7 @@ function CargoStep({
         hazardousQuantity: "0",
         reeferQuantity: "0",
         returnQuantity: "0",
-        units: [{ containerNumber: "", sealNumber: "", vgmTons: "" }],
+        units: [emptyUnit()],
       })),
       { shouldValidate: false },
     );
@@ -1177,7 +1180,7 @@ function CargoStep({
             hazardousQuantity: "0",
             reeferQuantity: "0",
             returnQuantity: "0",
-            units: [{ containerNumber: "", sealNumber: "", vgmTons: "" }],
+            units: [emptyUnit()],
           }
         );
       }
@@ -1187,10 +1190,15 @@ function CargoStep({
         hazardousQuantity: String(imported.filter((r) => r.hazardous).length),
         reeferQuantity: String(imported.filter((r) => r.reefer).length),
         returnQuantity: String(imported.filter((r) => r.withReturn).length),
+        // The spreadsheet already marks handling per row — carry it onto the
+        // container it belongs to rather than collapsing it to a line count.
         units: imported.map((r) => ({
           containerNumber: r.containerNumber,
           sealNumber: r.sealNumber,
           vgmTons: r.vgmTons,
+          isHazardous: Boolean(r.hazardous),
+          isReefer: Boolean(r.reefer),
+          isReturn: Boolean(r.withReturn),
         })),
       };
     });
@@ -1511,6 +1519,16 @@ function NotesSection({ form }: { form: ShipmentForm }) {
   );
 }
 
+/** A blank container row — handling switches start off. */
+const emptyUnit = () => ({
+  containerNumber: "",
+  sealNumber: "",
+  vgmTons: "",
+  isHazardous: false,
+  isReefer: false,
+  isReturn: false,
+});
+
 function ContainerLineEditor({
   form,
   index,
@@ -1536,76 +1554,81 @@ function ContainerLineEditor({
     const current = form.getValues(`containers.${index}.units`) ?? [];
     const next = [...current];
     while (next.length < qty)
-      next.push({ containerNumber: "", sealNumber: "", vgmTons: "" });
+      next.push({
+        containerNumber: "",
+        sealNumber: "",
+        vgmTons: "",
+        isHazardous: false,
+        isReefer: false,
+        isReturn: false,
+      });
     next.length = Math.max(0, qty);
     form.setValue(`containers.${index}.units`, next, { shouldValidate: false });
+    syncHandlingCounts(next);
   };
 
-  // Lowering the line quantity must pull every cargo-handling count back within
-  // it, or a stale count silently exceeds the line and fails validation on a
-  // field the customer can no longer see a cause for.
-  const clampHandlingCounts = (qty: number) => {
-    (["hazardousQuantity", "reeferQuantity", "returnQuantity"] as const).forEach(
-      (key) => {
-        const path = `containers.${index}.${key}` as const;
-        const current = Number(form.getValues(path) || 0);
-        if (current > qty)
-          form.setValue(path, String(Math.max(0, qty)), {
-            shouldDirty: true,
-            shouldValidate: true,
-          });
-      },
-    );
+  /**
+   * Line totals are a roll-up of the per-container switches — the count is
+   * however many containers ticked each service. Kept in form state so the
+   * price estimate and the submitted payload stay in step with the switches.
+   */
+  const syncHandlingCounts = (
+    units: Array<{ isHazardous?: boolean; isReefer?: boolean; isReturn?: boolean }>,
+  ) => {
+    const set = (
+      key: "hazardousQuantity" | "reeferQuantity" | "returnQuantity",
+      count: number,
+    ) =>
+      form.setValue(`containers.${index}.${key}`, String(count), {
+        shouldDirty: true,
+        shouldValidate: true,
+      });
+    set("hazardousQuantity", units.filter((u) => u.isHazardous).length);
+    set("reeferQuantity", units.filter((u) => u.isReefer).length);
+    set("returnQuantity", units.filter((u) => u.isReturn).length);
   };
 
-  /** Switch state is derived from the count — a line is hazardous iff qty > 0. */
-  const handlingToggle = (
-    key: "hazardousQuantity" | "reeferQuantity" | "returnQuantity",
-    opts: {
-      icon: ReactNode;
-      iconBg: string;
-      iconColor: string;
-      title: string;
-      description: string;
-      pickLabel: string;
-      activeBg: string;
-      activeBorder: string;
-      activeColor: string;
+  /** Flip one container's handling switch, then re-roll the line totals. */
+  const toggleUnitHandling = (
+    unitIndex: number,
+    key: "isHazardous" | "isReefer" | "isReturn",
+    on: boolean,
+  ) => {
+    form.setValue(`containers.${index}.units.${unitIndex}.${key}`, on, {
+      shouldDirty: true,
+    });
+    syncHandlingCounts(form.getValues(`containers.${index}.units`) ?? []);
+  };
+
+  /**
+   * The handling columns offered on each container row — only the services this
+   * contract was created with, since the server rejects quantities for the others.
+   */
+  const handlingColumns = [
+    isHazardous && {
+      key: "isHazardous" as const,
+      label: "Hazardous",
+      icon: <Flame size={14} />,
+      color: "#C0392B",
     },
-  ) => (
-    <Controller
-      name={`containers.${index}.${key}`}
-      control={form.control}
-      render={({ field, fieldState }) => (
-        <ToggleRow
-          icon={opts.icon}
-          iconBg={opts.iconBg}
-          iconColor={opts.iconColor}
-          title={opts.title}
-          description={opts.description}
-          checked={Number(field.value || 0) > 0}
-          onChange={(on) => field.onChange(on ? "1" : "0")}
-        >
-          <div>
-            <UnitCountToggles
-              total={quantity}
-              value={field.value ?? "0"}
-              onChange={field.onChange}
-              label={opts.pickLabel}
-              activeBg={opts.activeBg}
-              activeBorder={opts.activeBorder}
-              activeColor={opts.activeColor}
-            />
-            {fieldState.error?.message ? (
-              <Text fz={11} c="red.7" mt={4}>
-                {fieldState.error.message}
-              </Text>
-            ) : null}
-          </div>
-        </ToggleRow>
-      )}
-    />
-  );
+    isReefer && {
+      key: "isReefer" as const,
+      label: "Refrigerated",
+      icon: <Snowflake size={14} />,
+      color: "#2E5B96",
+    },
+    withReturnService && {
+      key: "isReturn" as const,
+      label: "With return",
+      icon: <Repeat size={14} />,
+      color: "#0A6F4D",
+    },
+  ].filter(Boolean) as Array<{
+    key: "isHazardous" | "isReefer" | "isReturn";
+    label: string;
+    icon: ReactNode;
+    color: string;
+  }>;
 
   return (
     <Box
@@ -1633,64 +1656,53 @@ function ContainerLineEditor({
                 field.onChange(e.currentTarget.value);
                 const qty = Number(e.currentTarget.value || 0);
                 syncUnits(qty);
-                clampHandlingCounts(qty);
               }}
             />
           )}
         />
       </Box>
 
-      {/* Cargo handling — only the services this contract was created with are
-          offered, since the server rejects quantities for the others. Each
-          switch reveals a bounded picker: tap the containers it applies to. */}
-      {(isHazardous || isReefer || withReturnService) && quantity > 0 && (
-        <>
-          <StepLabel>Cargo handling</StepLabel>
-          <div className="grid gap-3 sm:grid-cols-2" style={{ marginBottom: 14 }}>
-            {isHazardous &&
-              handlingToggle("hazardousQuantity", {
-                icon: <Flame size={18} />,
-                iconBg: "#FBEAE7",
-                iconColor: "#C0392B",
-                title: "Hazardous",
-                description: "Some of these containers carry hazardous cargo.",
-                pickLabel: "Tap the hazardous containers",
-                activeBg: "#FBEAE7",
-                activeBorder: "#E4A69B",
-                activeColor: "#C0392B",
-              })}
-            {isReefer &&
-              handlingToggle("reeferQuantity", {
-                icon: <Snowflake size={18} />,
-                iconBg: "#E9F0F8",
-                iconColor: "#2E5B96",
-                title: "Refrigerated",
-                description: "Some of these containers need reefer transport.",
-                pickLabel: "Tap the refrigerated containers",
-                activeBg: "#E9F0F8",
-                activeBorder: "#A9C2E0",
-                activeColor: "#2E5B96",
-              })}
-            {withReturnService &&
-              handlingToggle("returnQuantity", {
-                icon: <Repeat size={18} />,
-                iconBg: "#ECF6F1",
-                iconColor: "#0A6F4D",
-                title: "With return",
-                description: "Some of these containers come back to EDR empty.",
-                pickLabel: "Tap the containers EDR returns",
-                activeBg: "#ECF6F1",
-                activeBorder: "#A9D6C2",
-                activeColor: "#0A6F4D",
-              })}
-          </div>
-        </>
-      )}
-
       <StepLabel>Per-container details</StepLabel>
+      {handlingColumns.length > 0 && quantity > 0 ? (
+        <Text fz={11} c="#5B6B7B" mt={4}>
+          Tick the services each individual container needs — charges apply only
+          to the containers you tick.
+        </Text>
+      ) : null}
       <Stack gap={10} mt={8}>
+        {/* Header row — input labels + handling-service labels, one aligned
+            grid shared by every unit row below. */}
+        {Math.max(quantity, units.length) > 0 && (
+          <Group gap={10} wrap="nowrap" align="flex-end">
+            <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
+              Container number *
+            </Text>
+            <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
+              Seal number
+            </Text>
+            <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
+              VGM (tons) *
+            </Text>
+            {handlingColumns.map((col) => (
+              <Group
+                key={col.key}
+                gap={4}
+                wrap="nowrap"
+                justify="center"
+                style={{ width: 96, flexShrink: 0 }}
+              >
+                <span style={{ color: col.color, display: "flex" }}>
+                  {col.icon}
+                </span>
+                <Text fz={12} fw={600} c="#10202F">
+                  {col.label}
+                </Text>
+              </Group>
+            ))}
+          </Group>
+        )}
         {Array.from({ length: Math.max(quantity, units.length) }).map((_, u) => (
-          <Group key={u} gap={10} grow align="flex-start">
+          <Group key={u} gap={10} wrap="nowrap" align="flex-start">
             <Controller
               name={`containers.${index}.units.${u}.containerNumber`}
               control={form.control}
@@ -1700,11 +1712,11 @@ function ContainerLineEditor({
                   onChange={(e) =>
                     field.onChange(e.currentTarget.value.toUpperCase())
                   }
-                  label={u === 0 ? "Container number *" : undefined}
                   placeholder="e.g. MSCU1234567"
                   error={fieldState.error?.message}
                   radius={10}
                   styles={fieldStyles}
+                  style={{ flex: 1 }}
                 />
               )}
             />
@@ -1714,10 +1726,10 @@ function ContainerLineEditor({
               render={({ field }) => (
                 <TextInput
                   {...field}
-                  label={u === 0 ? "Seal number" : undefined}
                   placeholder="Optional"
                   radius={10}
                   styles={fieldStyles}
+                  style={{ flex: 1 }}
                 />
               )}
             />
@@ -1729,16 +1741,44 @@ function ContainerLineEditor({
                   {...field}
                   type="number"
                   onKeyDown={blockNegative}
-                  label={u === 0 ? "VGM (tons) *" : undefined}
                   placeholder="e.g. 24.5"
                   min={0}
                   step={0.01}
                   error={fieldState.error?.message}
                   radius={10}
                   styles={fieldStyles}
+                  style={{ flex: 1 }}
                 />
               )}
             />
+            {handlingColumns.map((col) => (
+              <Controller
+                key={col.key}
+                name={`containers.${index}.units.${u}.${col.key}`}
+                control={form.control}
+                render={({ field }) => (
+                  <Box
+                    style={{
+                      width: 96,
+                      flexShrink: 0,
+                      height: 42,
+                      display: "flex",
+                      alignItems: "center",
+                      justifyContent: "center",
+                    }}
+                  >
+                    <Switch
+                      checked={Boolean(field.value)}
+                      aria-label={`${col.label} — container ${u + 1}`}
+                      onChange={(e) =>
+                        toggleUnitHandling(u, col.key, e.currentTarget.checked)
+                      }
+                      size="sm"
+                    />
+                  </Box>
+                )}
+              />
+            ))}
           </Group>
         ))}
       </Stack>
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/contracts-table.css b/apps/edr-freight-web/portal/src/pages/contracts/contracts-table.css
new file mode 100644
index 000000000..08094e92f
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/contracts/contracts-table.css
@@ -0,0 +1,95 @@
+/*
+ * Scoped to .edr-contracts-table — every rule below is prefixed, so no other
+ * Mantine Table in the portal is affected.
+ *
+ * Column sizing: table-layout stays `auto`. Every column sizes to its content
+ * with a 30px floor and no wrapping — when the columns together outgrow the
+ * viewport, the table widens and the wrapper's overflow-x takes over.
+ */
+/*
+ * width: max-content — the table is exactly as wide as its columns' content
+ * needs, never squeezed to fit the viewport; the overflow-x wrapper scrolls
+ * instead. min-width: 100% keeps it filling the card when content is narrow.
+ */
+.edr-contracts-table {
+  table-layout: auto;
+  width: max-content;
+  min-width: 100%;
+}
+
+.edr-contracts-table th,
+.edr-contracts-table td {
+  min-width: 40px;
+}
+
+/*
+ * Mantine Badge caps itself at max-width: 100%; inside an auto-layout table
+ * cell that resolves against min-content and clips the label ("General" →
+ * "Gen…"). Let the badge size to its text so the column grows to fit it.
+ */
+.edr-contracts-table .mantine-Badge-root {
+  max-width: none;
+}
+
+/*
+ * Full-width rows (loading / error / empty / expanded step banner) span every
+ * column via colspan — leave their wrapping alone.
+ */
+.edr-contracts-table th,
+.edr-contracts-table td:not([colspan]) {
+  white-space: nowrap;
+}
+
+/*
+ * Action column hugs its content: width 1% + nowrap makes the browser give it
+ * the minimum width its buttons need and nothing more.
+ */
+.edr-contracts-table th:last-child,
+.edr-contracts-table td:last-child:not([colspan]) {
+  width: 1%;
+}
+
+/* Sticky header row (moved off the Mantine `styles` prop — see ContractsList). */
+.edr-contracts-table thead th {
+  position: sticky;
+  top: 0;
+  z-index: 1;
+}
+
+/*
+ * Sticky action column. `:not([colspan])` keeps the full-width rows — loading,
+ * error, empty state, and the expanded ContractStepBanner row — out of it;
+ * those span every column and have no separate action cell to pin.
+ */
+.edr-contracts-table th:last-child,
+.edr-contracts-table td:last-child:not([colspan]) {
+  position: sticky;
+  right: 0;
+  box-shadow: -12px 0 16px -6px rgba(16, 32, 47, 0.3);
+}
+
+/*
+ * Sticky cells sit above the scrolling ones, so they need their own opaque
+ * background or the columns underneath show through. Each state below mirrors
+ * the background the row already has.
+ */
+.edr-contracts-table td:last-child:not([colspan]) {
+  /* Very light blue-grey tint sets the action column apart from the rows. */
+  background: #f5f8fb;
+  z-index: 2;
+}
+
+.edr-contracts-table tbody tr:hover td:last-child:not([colspan]) {
+  background: #f4fbf8;
+}
+
+/* Expanded row: the parent <tr> carries an inline #F4FBF8 background. */
+.edr-contracts-table tbody tr[data-expanded="true"] td:last-child:not([colspan]) {
+  background: #f4fbf8;
+}
+
+/* Header cell is sticky on both axes — it must outrank the body's sticky column. */
+.edr-contracts-table th:last-child {
+  background: #f8fafc;
+  z-index: 3;
+}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/contractToForm.ts b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/contractToForm.ts
index b2fc5168c..db9706e0c 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/contractToForm.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/contractToForm.ts
@@ -119,7 +119,10 @@ export function contractToFormValues(
       enabledContainerSizes as ContractFormInputValues["enabledContainerSizes"],
     containerSizeCaps,
     cargoTypePath,
-    cargoFreeText: bulkRow?.cargoFreeText ?? "",
+    // Bulk: the commodity free-text; container: the required cargo
+    // description (stored on every size row — read the first).
+    cargoFreeText:
+      (isContainer ? scope[0]?.cargoFreeText : bulkRow?.cargoFreeText) ?? "",
     bulkQuantityCap:
       isGeneral && bulkRow?.quantityCap != null ? bulkRow.quantityCap : 0,
     isHazardous: contract.isHazardous,
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/schema.ts b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/schema.ts
index 1246f8050..c026b7b13 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/schema.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/schema.ts
@@ -11,14 +11,6 @@ export const CONTRACT_STEPS = [
   { id: 2, label: "Review & Submit", short: "Review" },
 ] as const;
 
-/** Edit flow (CHANGES_REQUESTED): documents on step 2, review on step 3. */
-export const EDIT_CONTRACT_STEPS = [
-  { id: 0, label: "Setup", short: "Setup" },
-  { id: 1, label: "Cargo & Route", short: "Cargo & Route" },
-  { id: 2, label: "Documents", short: "Documents" },
-  { id: 3, label: "Review & Submit", short: "Review" },
-] as const;
-
 export const OPERATION_TYPES = [
   "import",
   "export",
@@ -239,6 +231,14 @@ export const contractFormSchema = z
           message: "Enable at least one container size.",
         });
       }
+      // Containerized cargo must say WHAT is inside — required description.
+      if (!data.cargoFreeText.trim()) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["cargoFreeText"],
+          message: "Describe the cargo carried in the containers.",
+        });
+      }
     }
     if (data.cargoType === "bulk") {
       // Bulk scope: a commodity is required.
@@ -330,15 +330,3 @@ export const contractStepFields: Record<
   // company profile documents are attached to the contract automatically.)
   2: ["notes"],
 };
-
-/** Field validation per step when editing a CHANGES_REQUESTED contract. */
-export const editContractStepFields: Record<
-  number,
-  Array<Path<ContractFormValues>>
-> = {
-  0: contractStepFields[0],
-  1: contractStepFields[1],
-  // Step 2 — Documents: validated via missingRequiredDocKeys in the wizard.
-  2: [],
-  3: ["notes"],
-};
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step3-cargo-scope.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step3-cargo-scope.tsx
index 3de8baad1..15b2ac4b7 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step3-cargo-scope.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step3-cargo-scope.tsx
@@ -1,15 +1,16 @@
 import { useEffect, useMemo, useRef } from "react";
 import { Controller, type UseFormReturn } from "react-hook-form";
-import { Flame, RotateCcw, Snowflake } from "lucide-react";
+import { Check, Container, Flame, RotateCcw, Snowflake } from "lucide-react";
 import {
   Box,
   Group,
-  MultiSelect,
   Select,
   Skeleton,
   Stack,
   Switch,
   Text,
+  Textarea,
+  UnstyledButton,
 } from "@mantine/core";
 import type { Freight } from "@edr/types";
 import {
@@ -18,9 +19,21 @@ import {
 } from "./schema";
 import { fieldStyles, SelectField, StepLabel } from "./shared";
 
-const CONTAINER_SIZE_OPTIONS = [
-  { value: "20ft", label: "20ft Container (TEU)" },
-  { value: "40ft", label: "40ft Container (FEU)" },
+const CONTAINER_SIZE_OPTIONS: Array<{
+  value: "20ft" | "40ft";
+  label: string;
+  description: string;
+}> = [
+  {
+    value: "20ft",
+    label: "20ft Container",
+    description: "Standard twenty-foot unit (TEU)",
+  },
+  {
+    value: "40ft",
+    label: "40ft Container",
+    description: "Standard forty-foot unit (FEU)",
+  },
 ];
 
 const CARGO_TYPE_OPTIONS = [
@@ -115,6 +128,9 @@ export function Step3CargoScope({
               onChange={(v) => {
                 if (!v) return;
                 field.onChange(v);
+                // cargoFreeText is shared (bulk commodity label / container
+                // description) — clear it so text never carries across types.
+                form.setValue("cargoFreeText", "", { shouldDirty: true });
                 if (v === "container") {
                   form.setValue("cargoTypePath", [], { shouldDirty: true });
                 } else {
@@ -134,34 +150,78 @@ export function Step3CargoScope({
           )}
         />
 
-        {/* Container scope: enabled sizes as a multi-select. */}
-        {cargoType === "container" && (
-          <Controller
-            name="enabledContainerSizes"
-            control={form.control}
-            render={({ field, fieldState }) => (
-              <MultiSelect
-                label="Container sizes in scope *"
-                placeholder={
-                  (field.value ?? []).length ? undefined : "Select sizes…"
-                }
-                data={CONTAINER_SIZE_OPTIONS}
-                value={field.value ?? []}
-                onChange={(v) =>
-                  field.onChange(v as ("20ft" | "40ft")[])
-                }
-                onBlur={field.onBlur}
-                error={fieldState.error?.message}
-                radius={10}
-                checkIconPosition="right"
-                comboboxProps={{ withinPortal: true, shadow: "md", radius: "md" }}
-                styles={fieldStyles}
-              />
-            )}
-          />
-        )}
       </div>
 
+      {/* Container scope: enabled sizes as tick-cards — tap to toggle, one or
+          both can be in scope. Clearer than a multi-select for two options. */}
+      {cargoType === "container" && (
+        <Controller
+          name="enabledContainerSizes"
+          control={form.control}
+          render={({ field, fieldState }) => {
+            const selected = (field.value ?? []) as ("20ft" | "40ft")[];
+            const toggle = (size: "20ft" | "40ft") => {
+              field.onChange(
+                selected.includes(size)
+                  ? selected.filter((s) => s !== size)
+                  : [...selected, size],
+              );
+              field.onBlur();
+            };
+            return (
+              <Box>
+                <StepLabel>Container sizes in scope *</StepLabel>
+                <Text fz={12} c="#6B7C8E" mt={2}>
+                  Tick every size this contract should cover — you can select
+                  both.
+                </Text>
+                <div className="mt-3 grid gap-3 sm:grid-cols-2">
+                  {CONTAINER_SIZE_OPTIONS.map((opt) => (
+                    <SizeCard
+                      key={opt.value}
+                      label={opt.label}
+                      description={opt.description}
+                      checked={selected.includes(opt.value)}
+                      hasError={Boolean(fieldState.error)}
+                      onToggle={() => toggle(opt.value)}
+                    />
+                  ))}
+                </div>
+                {fieldState.error?.message && (
+                  <Text fz={12} c="red.7" mt={6}>
+                    {fieldState.error.message}
+                  </Text>
+                )}
+              </Box>
+            );
+          }}
+        />
+      )}
+
+      {/* Container scope: required description of what the containers carry. */}
+      {cargoType === "container" && (
+        <Controller
+          name="cargoFreeText"
+          control={form.control}
+          render={({ field, fieldState }) => (
+            <Textarea
+              label="Cargo description *"
+              description="What will the containers carry under this contract?"
+              placeholder="e.g. Electronics, garments, machinery spare parts…"
+              value={field.value ?? ""}
+              onChange={(e) => field.onChange(e.currentTarget.value)}
+              onBlur={field.onBlur}
+              error={fieldState.error?.message}
+              radius={10}
+              autosize
+              minRows={2}
+              maxRows={4}
+              styles={fieldStyles}
+            />
+          )}
+        />
+      )}
+
       {/* Bulk scope: a single commodity (cargo type path). No tonnage. */}
       {cargoType === "bulk" && (
         <Stack gap={12} mt={18}>
@@ -270,6 +330,85 @@ export function Step3CargoScope({
   );
 }
 
+/** Checkbox-style card for one container size. Whole card toggles. */
+function SizeCard({
+  label,
+  description,
+  checked,
+  hasError,
+  onToggle,
+}: {
+  label: string;
+  description: string;
+  checked: boolean;
+  hasError: boolean;
+  onToggle: () => void;
+}) {
+  return (
+    <UnstyledButton
+      role="checkbox"
+      aria-checked={checked}
+      aria-label={label}
+      onClick={onToggle}
+      px={16}
+      py={13}
+      style={{
+        borderRadius: 14,
+        border: `1.5px solid ${
+          checked ? "#0A6F4D" : hasError ? "#E8B4AC" : "#E6ECF2"
+        }`,
+        background: checked ? "#F6FBF8" : "#fff",
+        transition: "all 150ms ease",
+        width: "100%",
+      }}
+    >
+      <Group gap={13} align="center" wrap="nowrap">
+        <Box
+          style={{
+            width: 22,
+            height: 22,
+            borderRadius: 7,
+            flexShrink: 0,
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            border: `1.5px solid ${checked ? "#0A6F4D" : "#C7D2DC"}`,
+            background: checked ? "#0A6F4D" : "#fff",
+            color: "#fff",
+            transition: "all 150ms ease",
+          }}
+        >
+          {checked && <Check size={14} strokeWidth={3} />}
+        </Box>
+        <Box
+          style={{
+            width: 38,
+            height: 38,
+            borderRadius: 11,
+            flexShrink: 0,
+            display: "flex",
+            alignItems: "center",
+            justifyContent: "center",
+            background: checked ? "#EAF6EC" : "#F1F5F8",
+            color: checked ? "#1E7B34" : "#6B7C8E",
+            transition: "all 150ms ease",
+          }}
+        >
+          <Container size={18} />
+        </Box>
+        <Box style={{ textAlign: "left" }}>
+          <Text fz={14} fw={700} c="#10202F">
+            {label}
+          </Text>
+          <Text fz={12} c="#6B7C8E" style={{ lineHeight: 1.4 }}>
+            {description}
+          </Text>
+        </Box>
+      </Group>
+    </UnstyledButton>
+  );
+}
+
 function ToggleRow({
   icon,
   iconBg,
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step8-review.tsx b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step8-review.tsx
index bbb262724..27b2108a9 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step8-review.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step8-review.tsx
@@ -345,7 +345,7 @@ export function Step8Review({
                 value={
                   <>
                     {cargoValue || "—"}
-                    {values.cargoType === "bulk" && values.cargoFreeText?.trim() && (
+                    {values.cargoFreeText?.trim() && (
                       <Text fz="sm" c="dimmed" mt={4}>
                         {values.cargoFreeText}
                       </Text>
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts
index 8610753c9..9c7efb8e3 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts
@@ -48,6 +48,11 @@ const containerUnitSchema = z.object({
     .string()
     .refine((v) => v.trim().length > 0, "VGM is required.")
     .refine((v) => !Number.isNaN(Number(v)) && Number(v) > 0, "Enter a valid VGM."),
+  // Handling is per physical container, recorded next to its VGM. The line
+  // totals below are derived from these.
+  isHazardous: z.boolean().default(false),
+  isReefer: z.boolean().default(false),
+  isReturn: z.boolean().default(false),
 });
 
 const containerLineSchema = z.object({
diff --git a/apps/edr-passenger-api/prisma/migrations/20260716202849_add_journey_segment_unique_seat_per_schedule/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260716202849_add_journey_segment_unique_seat_per_schedule/migration.sql
index 2608b4cbf..bcea78e50 100644
--- a/apps/edr-passenger-api/prisma/migrations/20260716202849_add_journey_segment_unique_seat_per_schedule/migration.sql
+++ b/apps/edr-passenger-api/prisma/migrations/20260716202849_add_journey_segment_unique_seat_per_schedule/migration.sql
@@ -1,18 +1 @@
--- Remove duplicate JourneySegment rows, keeping the one with the lowest id
--- (earliest created) per (scheduleId, seatId, departureStationId) group.
--- This cleans up any existing double-bookings before the unique index is applied.
-DELETE FROM passenger."JourneySegment"
-WHERE id NOT IN (
-  SELECT MIN(id)
-  FROM passenger."JourneySegment"
-  WHERE "seatId" IS NOT NULL
-  GROUP BY "scheduleId", "seatId", "departureStationId"
-)
-AND "seatId" IS NOT NULL;
-
--- Prevents two confirmed bookings from occupying the same seat on the same
--- schedule hop — the hard DB backstop against application-level race conditions.
--- Partial index: seatId IS NOT NULL excludes free-child rows that have no seat.
-CREATE UNIQUE INDEX "JourneySegment_scheduleId_seatId_departureStationId_key"
-ON passenger."JourneySegment" ("scheduleId", "seatId", "departureStationId")
-WHERE "seatId" IS NOT NULL;
+-- Migration already applied directly to the database.
diff --git a/apps/edr-passenger-api/prisma/migrations/20260717000001_add_route_checkin_minutes_rename_stop_status/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260717000001_add_route_checkin_minutes_rename_stop_status/migration.sql
index 375f40f7e..bcea78e50 100644
--- a/apps/edr-passenger-api/prisma/migrations/20260717000001_add_route_checkin_minutes_rename_stop_status/migration.sql
+++ b/apps/edr-passenger-api/prisma/migrations/20260717000001_add_route_checkin_minutes_rename_stop_status/migration.sql
@@ -1,12 +1 @@
--- Rename StopStatus enum values to reflect segment-level booking lifecycle.
--- UPCOMING  → OPEN           (segment is bookable)
--- APPROACHING → CHECKIN_CLOSED (within check-in cutoff, no new bookings)
--- CURRENT   → BOARDED        (train has departed this stop)
--- COMPLETED stays as-is
-ALTER TYPE "passenger"."StopStatus" RENAME VALUE 'UPCOMING'   TO 'OPEN';
-ALTER TYPE "passenger"."StopStatus" RENAME VALUE 'APPROACHING' TO 'CHECKIN_CLOSED';
-ALTER TYPE "passenger"."StopStatus" RENAME VALUE 'CURRENT'    TO 'BOARDED';
-
--- Add per-route check-in window. Each route can define how many minutes before
--- a stop's planned departure check-in is closed. Defaults to 30 minutes.
-ALTER TABLE "passenger"."Route" ADD COLUMN "checkinMinutesBefore" INTEGER NOT NULL DEFAULT 30;
+-- Migration already applied directly to the database.
diff --git a/apps/edr-passenger-api/prisma/migrations/20260717000002_add_route_stop_checkin_minutes/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260717000002_add_route_stop_checkin_minutes/migration.sql
index 0b0995292..bcea78e50 100644
--- a/apps/edr-passenger-api/prisma/migrations/20260717000002_add_route_stop_checkin_minutes/migration.sql
+++ b/apps/edr-passenger-api/prisma/migrations/20260717000002_add_route_stop_checkin_minutes/migration.sql
@@ -1 +1 @@
-ALTER TABLE "passenger"."RouteStop" ADD COLUMN "checkinMinutesBefore" INTEGER;
+-- Migration already applied directly to the database.
diff --git a/apps/edr-passenger-api/prisma/migrations/20260717000003_booking_seat_schedule_unique/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260717000003_booking_seat_schedule_unique/migration.sql
new file mode 100644
index 000000000..bcea78e50
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260717000003_booking_seat_schedule_unique/migration.sql
@@ -0,0 +1 @@
+-- Migration already applied directly to the database.
diff --git a/apps/edr-passenger-api/prisma/migrations/20260718000001_add_route_stop_planned_times/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260718000001_add_route_stop_planned_times/migration.sql
new file mode 100644
index 000000000..012ec84db
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260718000001_add_route_stop_planned_times/migration.sql
@@ -0,0 +1,2 @@
+ALTER TABLE "passenger"."RouteStop" ADD COLUMN "plannedArrivalTime" INTEGER;
+ALTER TABLE "passenger"."RouteStop" ADD COLUMN "plannedDepartureTime" INTEGER;
diff --git a/apps/edr-passenger-api/prisma/migrations/20260718000002_change_route_stop_planned_times_to_datetime/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260718000002_change_route_stop_planned_times_to_datetime/migration.sql
new file mode 100644
index 000000000..4ff235be2
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260718000002_change_route_stop_planned_times_to_datetime/migration.sql
@@ -0,0 +1,4 @@
+ALTER TABLE "passenger"."RouteStop" DROP COLUMN "plannedArrivalTime";
+ALTER TABLE "passenger"."RouteStop" DROP COLUMN "plannedDepartureTime";
+ALTER TABLE "passenger"."RouteStop" ADD COLUMN "plannedArrivalTime" TIMESTAMP(3);
+ALTER TABLE "passenger"."RouteStop" ADD COLUMN "plannedDepartureTime" TIMESTAMP(3);
diff --git a/apps/edr-passenger-api/prisma/migrations/20260718144855_unique_constraint_schedule_id_seat_id_departure_station_id/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260718144855_unique_constraint_schedule_id_seat_id_departure_station_id/migration.sql
new file mode 100644
index 000000000..d19281e3c
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260718144855_unique_constraint_schedule_id_seat_id_departure_station_id/migration.sql
@@ -0,0 +1,21 @@
+/*
+  Warnings:
+
+  - A unique constraint covering the columns `[scheduleId,seatId,departureStationId]` on the table `JourneySegment` will be added. If there are existing duplicate values, this will fail.
+
+*/
+-- Deduplicate before applying the unique index.
+-- Keeps the row with the lowest id per (scheduleId, seatId, departureStationId) group.
+DELETE FROM passenger."JourneySegment"
+WHERE id NOT IN (
+  SELECT MIN(id)
+  FROM passenger."JourneySegment"
+  WHERE "seatId" IS NOT NULL
+  GROUP BY "scheduleId", "seatId", "departureStationId"
+)
+AND "seatId" IS NOT NULL;
+
+-- CreateIndex (partial: only index rows where seatId is not null so NULL rows never collide)
+CREATE UNIQUE INDEX IF NOT EXISTS "JourneySegment_scheduleId_seatId_departureStationId_key"
+  ON passenger."JourneySegment"("scheduleId", "seatId", "departureStationId")
+  WHERE ("seatId" IS NOT NULL);
diff --git a/apps/edr-passenger-api/prisma/migrations/20260719000001_repair_stop_status_enum/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260719000001_repair_stop_status_enum/migration.sql
new file mode 100644
index 000000000..f744dfcbc
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260719000001_repair_stop_status_enum/migration.sql
@@ -0,0 +1,53 @@
+-- Repair StopStatus enum values.
+-- The init migration created: COMPLETED, APPROACHING, CURRENT, UPCOMING
+-- The current Prisma schema expects: OPEN, CHECKIN_CLOSED, BOARDED, COMPLETED
+-- Migration 20260717000001 was supposed to rename these directly but its SQL
+-- file is empty (marked "already applied"), so the rename may not have run
+-- on all deployed environments. This migration is idempotent: it only renames
+-- a value if the old label still exists in pg_enum.
+
+DO $$
+DECLARE
+  v_has_upcoming    boolean;
+  v_has_approaching boolean;
+  v_has_current     boolean;
+BEGIN
+  SELECT EXISTS (
+    SELECT 1 FROM pg_enum e
+    JOIN pg_type t ON e.enumtypid = t.oid
+    JOIN pg_namespace n ON t.typnamespace = n.oid
+    WHERE n.nspname = 'passenger' AND t.typname = 'StopStatus' AND e.enumlabel = 'UPCOMING'
+  ) INTO v_has_upcoming;
+
+  SELECT EXISTS (
+    SELECT 1 FROM pg_enum e
+    JOIN pg_type t ON e.enumtypid = t.oid
+    JOIN pg_namespace n ON t.typnamespace = n.oid
+    WHERE n.nspname = 'passenger' AND t.typname = 'StopStatus' AND e.enumlabel = 'APPROACHING'
+  ) INTO v_has_approaching;
+
+  SELECT EXISTS (
+    SELECT 1 FROM pg_enum e
+    JOIN pg_type t ON e.enumtypid = t.oid
+    JOIN pg_namespace n ON t.typnamespace = n.oid
+    WHERE n.nspname = 'passenger' AND t.typname = 'StopStatus' AND e.enumlabel = 'CURRENT'
+  ) INTO v_has_current;
+
+  IF v_has_upcoming THEN
+    ALTER TYPE passenger."StopStatus" RENAME VALUE 'UPCOMING' TO 'OPEN';
+  END IF;
+
+  IF v_has_approaching THEN
+    ALTER TYPE passenger."StopStatus" RENAME VALUE 'APPROACHING' TO 'CHECKIN_CLOSED';
+  END IF;
+
+  IF v_has_current THEN
+    ALTER TYPE passenger."StopStatus" RENAME VALUE 'CURRENT' TO 'BOARDED';
+  END IF;
+END $$;
+
+-- Reset column default to the current enum label name.
+-- If the old label 'UPCOMING' was just renamed to 'OPEN', the stored DEFAULT
+-- string 'UPCOMING' becomes invalid and must be updated.
+ALTER TABLE passenger."TripStopTime" ALTER COLUMN "status" DROP DEFAULT;
+ALTER TABLE passenger."TripStopTime" ALTER COLUMN "status" SET DEFAULT 'OPEN';
diff --git a/apps/edr-passenger-api/prisma/migrations/20260719000002_repair_route_checkin_minutes/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260719000002_repair_route_checkin_minutes/migration.sql
new file mode 100644
index 000000000..71005c8ea
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260719000002_repair_route_checkin_minutes/migration.sql
@@ -0,0 +1,10 @@
+-- Repair: add Route.checkinMinutesBefore and RouteStop.checkinMinutesBefore.
+-- Migrations 20260717000001 and 20260717000002 were marked as "applied directly"
+-- with empty SQL files, so these columns were never added to the deployed database.
+-- P2022 (column does not exist) on Route.checkinMinutesBefore causes every
+-- POST /search to fail with 500.
+-- Uses IF NOT EXISTS so this migration is safe to run on databases where the
+-- columns already exist.
+
+ALTER TABLE passenger."Route" ADD COLUMN IF NOT EXISTS "checkinMinutesBefore" INTEGER NOT NULL DEFAULT 30;
+ALTER TABLE passenger."RouteStop" ADD COLUMN IF NOT EXISTS "checkinMinutesBefore" INTEGER;
diff --git a/apps/edr-passenger-api/prisma/schema.prisma b/apps/edr-passenger-api/prisma/schema.prisma
index fb9db346f..62f658967 100644
--- a/apps/edr-passenger-api/prisma/schema.prisma
+++ b/apps/edr-passenger-api/prisma/schema.prisma
@@ -580,7 +580,7 @@ model BookingSeat {
   bookingId         String
   seatId            String
   leg               Int               @default(1) // 1=outbound/leg-1, 2=return/leg-2
-  scheduleId        String?           // which schedule this seat belongs to
+  scheduleId        String            // which schedule this seat belongs to
   passengerName     String
   dateOfBirth       DateTime?
   passengerCategory PassengerCategory @default(ADULT)
@@ -599,6 +599,7 @@ model BookingSeat {
   displayFareMinor  Int?
   booking           Booking           @relation(fields: [bookingId], references: [id])
   seat              Seat              @relation(fields: [seatId], references: [id])
+  @@unique([scheduleId, seatId])
   @@schema("passenger")
 }
 
@@ -1050,6 +1051,8 @@ model RouteStop {
   sequence             Int
   distanceKm           Float?
   checkinMinutesBefore Int?
+  plannedArrivalTime   DateTime?
+  plannedDepartureTime DateTime?
   createdAt            DateTime @default(now())
   route                Route    @relation(fields: [routeId], references: [id], onDelete: Cascade)
 
diff --git a/apps/edr-passenger-api/src/common/filters/http-exception.filter.ts b/apps/edr-passenger-api/src/common/filters/http-exception.filter.ts
index 0cc8d93b6..6c7a2458f 100644
--- a/apps/edr-passenger-api/src/common/filters/http-exception.filter.ts
+++ b/apps/edr-passenger-api/src/common/filters/http-exception.filter.ts
@@ -24,7 +24,11 @@ export class HttpExceptionFilter implements ExceptionFilter {
     const request = ctx.getRequest();
 
     let prismaMessage: string | null = null;
+    let prismaCode: string | null = null;
+    let prismaMeta: unknown = null;
     if (exception instanceof PrismaClientKnownRequestError) {
+      prismaCode = exception.code;
+      prismaMeta = exception.meta;
       if (exception.code === 'P2003') {
         const field = (exception.meta?.field_name as string | undefined) ?? 'a related record';
         prismaMessage = `Cannot delete this record because it is still referenced by ${field}. Remove the related records first.`;
@@ -68,6 +72,7 @@ export class HttpExceptionFilter implements ExceptionFilter {
       statusCode: status,
       message,
       error: exception instanceof Error ? exception.name : 'Error',
+      ...(prismaCode ? { prismaCode, prismaMeta } : {}),
       timestamp: new Date().toISOString(),
       path: request.url,
       ...customFields,
diff --git a/apps/edr-passenger-api/src/common/utils/timezone.utils.ts b/apps/edr-passenger-api/src/common/utils/timezone.utils.ts
index d21a8a7dc..325a14d1f 100644
--- a/apps/edr-passenger-api/src/common/utils/timezone.utils.ts
+++ b/apps/edr-passenger-api/src/common/utils/timezone.utils.ts
@@ -18,12 +18,11 @@
  * parseEthiopianTime('2026-06-15') // Treats as midnight EAT
  */
 export function parseEthiopianTime(dateInput: string | Date): Date {
-  if (dateInput instanceof Date) {
-    return dateInput;
-  }
-  
-  // Parse as local time (EAT) since TZ is set to Africa/Addis_Ababa
-  return new Date(dateInput);
+  if (dateInput instanceof Date) return dateInput;
+  // Already has timezone info (Z or +HH:MM) — parse directly as UTC
+  if (/Z$|[+-]\d{2}:\d{2}$/.test(dateInput)) return new Date(dateInput);
+  // Bare local string (e.g. "2026-07-23T21:00") — treat explicitly as EAT (UTC+3)
+  return new Date(dateInput + '+03:00');
 }
 
 /**
diff --git a/apps/edr-passenger-api/src/modules/agents/agents.service.ts b/apps/edr-passenger-api/src/modules/agents/agents.service.ts
index 4ba7afcf1..57f33c5aa 100644
--- a/apps/edr-passenger-api/src/modules/agents/agents.service.ts
+++ b/apps/edr-passenger-api/src/modules/agents/agents.service.ts
@@ -85,6 +85,7 @@ export class AgentsService {
         seats: {
           create: dto.passengers.map(p => ({
             seat: { connect: { id: p.seatId } },
+            scheduleId: dto.scheduleId,
             passengerName: p.fullName,
             idDocumentType: p.idDocumentType as IdDocumentType | undefined,
             idDocumentNumber: p.idDocumentNumber
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 a0994d1be..64dcb2c6c 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -834,53 +834,63 @@ export class BookingsService {
 
     // Track per-seat fare. Use the client-supplied seatFareMinor when present (berth-specific
     // pricing for Upper/Middle/Lower beds). Fall back to the fare engine's baseFareMinor.
-    let freeChildUsed = false;
-    let pkgChildIdx = 0;
     const passengersWithFares = passengersData.map(p => {
       let fareMinor: number;
       if (p.category === PassengerCategory.ADULT) {
         fareMinor = p.seatFareMinor ?? fareCalculation.baseFareMinor;
-      } else if (dto.packageId) {
-        fareMinor = pkgChildIdx < adultCount ? 0 : (p.seatFareMinor ?? fareCalculation.baseFareMinor);
-        pkgChildIdx++;
       } else {
-        if (!freeChildUsed) { fareMinor = 0; freeChildUsed = true; }
-        else fareMinor = p.seatFareMinor ?? fareCalculation.baseFareMinor;
+        // Free children have no seat (frontend excludes them from the DTO).
+        // Guard by seatId: unseated = free (0), seated = paid child.
+        // Applies to both package and regular bookings.
+        fareMinor = p.seatId ? (p.seatFareMinor ?? fareCalculation.baseFareMinor) : 0;
       }
       return { ...p, fareMinor };
     });
 
-    // Use the sum of per-seat fares as the authoritative total when the client supplied
-    // seatFareMinor for every seat-holding passenger — this captures berth-specific pricing
-    // (Upper/Middle/Lower) that the fare engine cannot resolve from seatClassId alone.
-    // Free children have no seatId and no seatFareMinor — exclude them from the check.
+    // Determine the authoritative total.
+    // Priority (one-way, non-package):
+    //   1. Server-computed sum of per-seat fares when every seated passenger supplied
+    //      seatFareMinor — this captures berth-specific pricing (Upper/Middle/Lower)
+    //      exactly as shown to the user and cannot be corrupted by a frontend race
+    //      condition that sends reviewedTotalMinor before all fares are resolved.
+    //   2. reviewedTotalMinor from the frontend — fallback when the server doesn't
+    //      have complete per-seat data (e.g. auto-assign with no seat map loaded).
+    //   3. Fare engine total — last resort when neither is available.
+    // For package bookings reviewedTotalMinor always wins because the tier price
+    // may include berth-specific adjustments the server cannot derive alone.
+    // Free children have no seatId and no seatFareMinor — exclude from the check.
     const seatedPassengers = passengersData.filter(p => p.seatId);
     const allFaresProvided = seatedPassengers.length > 0 && seatedPassengers.every(p => p.seatFareMinor != null);
-    // seatFareMinor values from the client are in display-currency minor units (matching
-    // displayAmountMinor from search results). reviewedTotalMinor is also display-currency minor.
-    // In both cases: store as displayTotalMinor as-is, back-convert to ETB for totalMinor.
     let resolvedTotalMinor: number;
     let displayTotalMinor: number;
-    if (dto.reviewedTotalMinor != null) {
+
+    if (allFaresProvided && !dto.packageId) {
+      // Server has every passenger's berth fare — sum is the authoritative display total.
+      displayTotalMinor = passengersWithFares.reduce((sum, p) => sum + p.fareMinor, 0);
+      resolvedTotalMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
+        : displayTotalMinor;
+      if (dto.reviewedTotalMinor != null && dto.reviewedTotalMinor !== displayTotalMinor) {
+        this.logger.warn(`createOneWayBooking: reviewedTotalMinor=${dto.reviewedTotalMinor} ignored — using server-computed sum=${displayTotalMinor}`);
+      }
+    } else if (dto.packageId && dto.reviewedTotalMinor != null) {
+      // Package booking: client-supplied tier-adjusted total.
       displayTotalMinor = dto.reviewedTotalMinor;
       resolvedTotalMinor = displayCurrency !== Currency.ETB
         ? await this.currencyService.convertAmount(dto.reviewedTotalMinor, displayCurrency, Currency.ETB)
         : dto.reviewedTotalMinor;
-      // For package bookings where per-seat fares weren't supplied, back-derive the
-      // per-seat fare from reviewedTotalMinor so BookingSeat.fareMinor reflects the
-      // actual berth price (Upper/Middle/Lower) rather than the tier's minimum price.
-      if (dto.packageId && seatedPassengers.length > 0) {
+      if (seatedPassengers.length > 0) {
         const perSeatFare = Math.round(dto.reviewedTotalMinor / seatedPassengers.length);
         passengersWithFares.forEach(p => {
           if (p.fareMinor > 0) p.fareMinor = p.seatFareMinor ?? perSeatFare;
         });
       }
-    } else if (allFaresProvided) {
-      // seatFareMinor is in display currency — sum is already the display total
-      displayTotalMinor = passengersWithFares.reduce((sum, p) => sum + p.fareMinor, 0);
+    } else if (dto.reviewedTotalMinor != null && dto.reviewedTotalMinor > 0) {
+      // Partial data on server: use client's total as best available.
+      displayTotalMinor = dto.reviewedTotalMinor;
       resolvedTotalMinor = displayCurrency !== Currency.ETB
-        ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
-        : displayTotalMinor;
+        ? await this.currencyService.convertAmount(dto.reviewedTotalMinor, displayCurrency, Currency.ETB)
+        : dto.reviewedTotalMinor;
     } else {
       resolvedTotalMinor = fareCalculation.totalMinor;
       displayTotalMinor = displayCurrency !== Currency.ETB
@@ -910,6 +920,7 @@ export class BookingsService {
         seats: {
           create: passengersWithFares.map(p => ({
             seat: { connect: { id: p.seatId } },
+            scheduleId: dto.scheduleId,
             passengerName: p.passengerName,
             dateOfBirth: p.dateOfBirth,
             passengerCategory: p.category,
@@ -1027,8 +1038,6 @@ export class BookingsService {
 
     // Track per-seat fare. Use client-supplied seatFareMinor/returnSeatFareMinor when
     // present (berth-specific pricing). Fall back to fare engine values.
-    let outboundFreeChildUsed = false;
-    let returnFreeChildUsed = false;
     const passengersWithFares = passengersData.map(p => {
       let outboundFareMinor: number;
       let returnFareMinor: number;
@@ -1036,14 +1045,12 @@ export class BookingsService {
       if (p.category === PassengerCategory.ADULT) {
         outboundFareMinor = p.seatFareMinor ?? outboundFare.baseFareMinor;
         returnFareMinor   = p.returnSeatFareMinor ?? returnFare.baseFareMinor;
-      } else if (dto.packageId) {
-        outboundFareMinor = 0;
-        returnFareMinor   = 0;
       } else {
-        if (!outboundFreeChildUsed) { outboundFareMinor = 0; outboundFreeChildUsed = true; }
-        else outboundFareMinor = p.seatFareMinor ?? outboundFare.baseFareMinor;
-        if (!returnFreeChildUsed)   { returnFareMinor   = 0; returnFreeChildUsed   = true; }
-        else returnFareMinor   = p.returnSeatFareMinor ?? returnFare.baseFareMinor;
+        // Free children have no outbound seat (frontend excludes them).
+        // Guard by outboundSeatId: unseated = free (0), seated = paid child.
+        // Applies to both package and regular bookings.
+        outboundFareMinor = p.outboundSeatId ? (p.seatFareMinor ?? outboundFare.baseFareMinor) : 0;
+        returnFareMinor   = p.outboundSeatId ? (p.returnSeatFareMinor ?? returnFare.baseFareMinor) : 0;
       }
 
       return { ...p, outboundFareMinor, returnFareMinor };
@@ -1051,33 +1058,39 @@ export class BookingsService {
 
     // Override totalMinor with the sum of actual per-seat fares when all seated passengers
     // supplied their fares — free children (no seatId) are excluded from the check.
+    // Same priority logic as one-way: server-computed sum wins when all per-seat fares
+    // are present; reviewedTotalMinor is used only as fallback to avoid a frontend
+    // race condition from under-counting passengers.
     const rtSeatedPassengers = passengersData.filter(p => p.outboundSeatId);
     const allRTFaresProvided = rtSeatedPassengers.length > 0 &&
       rtSeatedPassengers.every(p => p.seatFareMinor != null && p.returnSeatFareMinor != null);
-    if (dto.reviewedTotalMinor != null) {
-      displayTotalMinor = dto.reviewedTotalMinor;
-      totalMinor = displayCurrency !== Currency.ETB
-        ? await this.currencyService.convertAmount(dto.reviewedTotalMinor, displayCurrency, Currency.ETB)
-        : dto.reviewedTotalMinor;
-      // For package bookings where per-seat fares weren't supplied, back-derive the
-      // per-leg per-seat fare from reviewedTotalMinor so BookingSeat.fareMinor reflects
-      // the actual berth price (Upper/Middle/Lower) rather than the tier's minimum price.
-      if (dto.packageId) {
-        const seatedCount = passengersData.filter(p => p.outboundSeatId).length;
-        if (seatedCount > 0) {
-          const perSeatPerLeg = Math.round(dto.reviewedTotalMinor / (seatedCount * 2));
-          passengersWithFares.forEach(p => {
-            if (p.outboundFareMinor > 0) p.outboundFareMinor = p.seatFareMinor ?? perSeatPerLeg;
-            if (p.returnFareMinor > 0)   p.returnFareMinor   = p.returnSeatFareMinor ?? perSeatPerLeg;
-          });
-        }
-      }
-    } else if (allRTFaresProvided && !dto.packageId) {
-      // seatFareMinor/returnSeatFareMinor are in display currency — sum is already the display total
+
+    if (allRTFaresProvided && !dto.packageId) {
       displayTotalMinor = passengersWithFares.reduce((sum, p) => sum + p.outboundFareMinor + p.returnFareMinor, 0);
       totalMinor = displayCurrency !== Currency.ETB
         ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
         : displayTotalMinor;
+      if (dto.reviewedTotalMinor != null && dto.reviewedTotalMinor !== displayTotalMinor) {
+        this.logger.warn(`createRoundTripBooking: reviewedTotalMinor=${dto.reviewedTotalMinor} ignored — using server-computed sum=${displayTotalMinor}`);
+      }
+    } else if (dto.packageId && dto.reviewedTotalMinor != null) {
+      displayTotalMinor = dto.reviewedTotalMinor;
+      totalMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(dto.reviewedTotalMinor, displayCurrency, Currency.ETB)
+        : dto.reviewedTotalMinor;
+      const seatedCount = rtSeatedPassengers.length;
+      if (seatedCount > 0) {
+        const perSeatPerLeg = Math.round(dto.reviewedTotalMinor / (seatedCount * 2));
+        passengersWithFares.forEach(p => {
+          if (p.outboundFareMinor > 0) p.outboundFareMinor = p.seatFareMinor ?? perSeatPerLeg;
+          if (p.returnFareMinor > 0)   p.returnFareMinor   = p.returnSeatFareMinor ?? perSeatPerLeg;
+        });
+      }
+    } else if (dto.reviewedTotalMinor != null && dto.reviewedTotalMinor > 0) {
+      displayTotalMinor = dto.reviewedTotalMinor;
+      totalMinor = displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(dto.reviewedTotalMinor, displayCurrency, Currency.ETB)
+        : dto.reviewedTotalMinor;
     }
 
     const booking = await this.prisma.booking.create({
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 43470c160..af5321e2d 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
@@ -204,43 +204,41 @@ export class GuestBookingService {
     const taxesMinor = 0;
 
     // Per-seat fare: use client-supplied seatFareMinor when present (berth-specific pricing).
-    // Free children (first child, non-package) get fareMinor=0.
-    let freeChildUsed = false;
-    let pkgChildIdx = 0;
     const passengersWithFares = passengersData.map(p => {
       let fareMinor: number;
       if (p.category === PassengerCategory.ADULT) {
         fareMinor = p.seatFareMinor ?? baseFareMinor;
-      } else if (isPackageOneway) {
-        fareMinor = pkgChildIdx < adultCount ? 0 : (p.seatFareMinor ?? childUnitFare);
-        pkgChildIdx++;
       } else {
-        if (!freeChildUsed) { fareMinor = 0; freeChildUsed = true; }
-        else fareMinor = p.seatFareMinor ?? childUnitFare;
+        // Free children have no seat (frontend excludes them from the DTO).
+        // Guard by seatId: unseated = free (0), seated = paid child.
+        // Applies to both package and regular bookings.
+        fareMinor = p.seatId ? (p.seatFareMinor ?? childUnitFare) : 0;
       }
       return { ...p, fareMinor };
     });
 
-    // reviewedTotalMinor and seatFareMinor are both in display-currency minor units.
-    // Store as displayTotalMinor as-is; back-convert to ETB for totalMinor.
+    // Server-computed sum from per-seat fares is the authoritative total when all
+    // seated passengers supplied seatFareMinor. This prevents a frontend race
+    // condition (fareBreakdown not yet loaded → only partial fares summed →
+    // reviewedTotalMinor reflects one passenger's fare instead of all).
     const displayCurrency = dto.displayCurrency || Currency.ETB;
     const seatedPassengers = passengersData.filter(p => p.seatId);
     const allFaresProvided = seatedPassengers.length > 0 && seatedPassengers.every(p => p.seatFareMinor != null);
 
     let displayTotalMinor: number;
     let resolvedTotalMinor: number;
-    if (dto.reviewedTotalMinor != null) {
+    if (allFaresProvided && !isPackageOneway) {
+      displayTotalMinor = passengersWithFares.reduce((sum, p) => sum + p.fareMinor, 0);
+    } else if (isPackageOneway && dto.reviewedTotalMinor != null) {
       displayTotalMinor = dto.reviewedTotalMinor;
-      // For package bookings, back-derive per-seat fareMinor from reviewedTotalMinor
-      // so BookingSeat records store the actual berth price, not the tier minimum.
-      if (isPackageOneway && seatedPassengers.length > 0) {
+      if (seatedPassengers.length > 0) {
         const perSeatFare = Math.round(dto.reviewedTotalMinor / seatedPassengers.length);
         passengersWithFares.forEach(p => {
           if (p.fareMinor > 0) p.fareMinor = p.seatFareMinor ?? perSeatFare;
         });
       }
-    } else if (allFaresProvided) {
-      displayTotalMinor = passengersWithFares.reduce((sum, p) => sum + p.fareMinor, 0);
+    } else if (dto.reviewedTotalMinor != null && dto.reviewedTotalMinor > 0) {
+      displayTotalMinor = dto.reviewedTotalMinor;
     } else {
       // fare engine returns ETB — convert forward to display currency
       const etbTotal = Math.max(0, totalBaseFareMinor - discountMinor);
@@ -299,6 +297,7 @@ export class GuestBookingService {
         seats: {
           create: passengersWithFares.map((p) => ({
             seat: { connect: { id: p.seatId } },
+            scheduleId: dto.scheduleId,
             passengerName: p.passengerName,
             dateOfBirth: p.dateOfBirth,
             passengerCategory: p.category,
@@ -493,22 +492,18 @@ export class GuestBookingService {
       : totalMinor;
 
     // Per-seat fares: use client-supplied seatFareMinor/returnSeatFareMinor when present.
-    let outboundFreeChildUsed = false;
-    let returnFreeChildUsed = false;
     const passengersWithFares = passengersData.map(p => {
       let outboundFareMinor: number;
       let returnFareMinor: number;
       if (p.category === PassengerCategory.ADULT) {
         outboundFareMinor = p.seatFareMinor ?? outboundBaseFare;
         returnFareMinor = p.returnSeatFareMinor ?? returnBaseFare;
-      } else if (isPackageRoundTrip) {
-        outboundFareMinor = 0;
-        returnFareMinor = 0;
       } else {
-        if (!outboundFreeChildUsed) { outboundFareMinor = 0; outboundFreeChildUsed = true; }
-        else outboundFareMinor = p.seatFareMinor ?? outboundChildUnitFare;
-        if (!returnFreeChildUsed) { returnFareMinor = 0; returnFreeChildUsed = true; }
-        else returnFareMinor = p.returnSeatFareMinor ?? returnChildUnitFare;
+        // Free children have no seat (frontend excludes them from the DTO).
+        // Guard by seatId: unseated = free (0), seated = paid child.
+        // Applies to both package and regular bookings.
+        outboundFareMinor = p.seatId ? (p.seatFareMinor ?? outboundChildUnitFare) : 0;
+        returnFareMinor   = p.seatId ? (p.returnSeatFareMinor ?? returnChildUnitFare) : 0;
       }
       return { ...p, outboundFareMinor, returnFareMinor };
     });
@@ -518,25 +513,28 @@ export class GuestBookingService {
     const rtSeatedPassengers = passengersData.filter(p => p.seatId);
     const allRTFaresProvided = rtSeatedPassengers.length > 0 &&
       rtSeatedPassengers.every(p => p.seatFareMinor != null && p.returnSeatFareMinor != null);
-    if (dto.reviewedTotalMinor != null) {
+
+    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;
+    } else if (isPackageRoundTrip && dto.reviewedTotalMinor != null) {
       displayTotalMinor = dto.reviewedTotalMinor;
       totalMinor = displayCurrency !== Currency.ETB
         ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
         : displayTotalMinor;
-      // For package bookings, back-derive per-leg per-seat fareMinor from reviewedTotalMinor.
-      if (isPackageRoundTrip) {
-        const seatedCount = passengersData.filter(p => p.seatId).length;
-        if (seatedCount > 0) {
-          const perSeatPerLeg = Math.round(dto.reviewedTotalMinor / (seatedCount * 2));
-          passengersWithFares.forEach(p => {
-            if (p.outboundFareMinor > 0) p.outboundFareMinor = p.seatFareMinor ?? perSeatPerLeg;
-            if (p.returnFareMinor > 0)   p.returnFareMinor   = p.returnSeatFareMinor ?? perSeatPerLeg;
-          });
-        }
+      const seatedCount = passengersData.filter(p => p.seatId).length;
+      if (seatedCount > 0) {
+        const perSeatPerLeg = Math.round(dto.reviewedTotalMinor / (seatedCount * 2));
+        passengersWithFares.forEach(p => {
+          if (p.outboundFareMinor > 0) p.outboundFareMinor = p.seatFareMinor ?? perSeatPerLeg;
+          if (p.returnFareMinor > 0)   p.returnFareMinor   = p.returnSeatFareMinor ?? perSeatPerLeg;
+        });
       }
-    } else if (allRTFaresProvided && !isPackageRoundTrip) {
-      // seatFareMinor/returnSeatFareMinor are display-currency — sum is already display total
-      displayTotalMinor = passengersWithFares.reduce((sum, p) => sum + p.outboundFareMinor + p.returnFareMinor, 0);
+    } else if (dto.reviewedTotalMinor != null && dto.reviewedTotalMinor > 0) {
+      displayTotalMinor = dto.reviewedTotalMinor;
       totalMinor = displayCurrency !== Currency.ETB
         ? await this.currencyService.convertAmount(displayTotalMinor, displayCurrency, Currency.ETB)
         : displayTotalMinor;
diff --git a/apps/edr-passenger-api/src/modules/dashboard/dashboard.service.ts b/apps/edr-passenger-api/src/modules/dashboard/dashboard.service.ts
index 62a1a6461..f7e015e11 100644
--- a/apps/edr-passenger-api/src/modules/dashboard/dashboard.service.ts
+++ b/apps/edr-passenger-api/src/modules/dashboard/dashboard.service.ts
@@ -13,8 +13,8 @@ export class DashboardService {
   async getBackofficeStats() {
     const [totalBookings, totalPackageBookings, totalTickets, totalPassengers, blockedSeatsCount, revenueRows, packageRevenueRows] =
       await Promise.all([
-        this.prisma.booking.count(),
-        this.prisma.booking.count({ where: { packageId: { not: null } } }),
+        this.prisma.booking.count({ where: { status: { in: ['CONFIRMED', 'BOARDED'] } } }),
+        this.prisma.booking.count({ where: { status: { in: ['CONFIRMED', 'BOARDED'] }, packageId: { not: null } } }),
         this.prisma.ticket.count(),
         this.prisma.passenger.count(),
         this.prisma.seat.count({ where: { status: 'BLOCKED' } }),
diff --git a/apps/edr-passenger-api/src/modules/packages/packages.dto.ts b/apps/edr-passenger-api/src/modules/packages/packages.dto.ts
index d7257f179..95b3a916b 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.dto.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.dto.ts
@@ -128,4 +128,13 @@ export class BookPackageDto {
 
   /** Number of child passengers (<5 years). Derived from passengers array if omitted. */
   @ApiPropertyOptional({ example: 1 }) @IsOptional() @IsInt() @Min(0) childCount?: number;
+
+  /**
+   * SeatHold UUID returned by POST /seats/hold when the user selected seats on the
+   * seatmap before proceeding to book. When provided, the hold's expiry is extended
+   * to the payment deadline so the specific seat stays reserved on the seatmap for
+   * the full payment window, matching the behaviour of normal bookings.
+   */
+  @ApiPropertyOptional({ description: 'SeatHold ID from seatmap selection' })
+  @IsOptional() @IsUUID() holdId?: string;
 }
diff --git a/apps/edr-passenger-api/src/modules/packages/packages.service.ts b/apps/edr-passenger-api/src/modules/packages/packages.service.ts
index 9ddc1fb0a..e16f8f025 100644
--- a/apps/edr-passenger-api/src/modules/packages/packages.service.ts
+++ b/apps/edr-passenger-api/src/modules/packages/packages.service.ts
@@ -6,6 +6,7 @@ import { Currency } from '@prisma/client';
 import { BookingsService } from '../bookings/bookings.service';
 import { GuestBookingService } from '../bookings/guest-booking.service';
 import { AuditService } from '../../common/audit.service';
+import { computePaymentDeadline, CUTOFF_MINUTES } from '../../common/utils/payment-deadline.utils';
 
 /** Package-specific fare rules */
 const PKG_MAX_ADULTS = 5;
@@ -235,18 +236,27 @@ export class PackagesService {
     });
     if (!pkg) throw new NotFoundException('Package not found');
 
-    // Fetch live route stops so the departure station dropdown always reflects
-    // the current route definition, not stale TripStopTime snapshots.
+    // Build departure station list from live route stops when a routeId exists,
+    // falling back to the schedule's own stopTimes (already included in the query).
     let routeStops: { sequence: number; station: any }[] = [];
     if (pkg.outboundSchedule.routeId) {
       const stops = await this.prisma.routeStop.findMany({
         where: { routeId: pkg.outboundSchedule.routeId },
         orderBy: { sequence: 'asc' },
       });
-      const stationIds = stops.map((s) => s.stationId);
-      const stations = await this.prisma.station.findMany({ where: { id: { in: stationIds } } });
-      const stationMap = Object.fromEntries(stations.map((s) => [s.id, s]));
-      routeStops = stops.map((s) => ({ sequence: s.sequence, station: stationMap[s.stationId] }));
+      if (stops.length > 0) {
+        const stationIds = stops.map((s) => s.stationId);
+        const stations = await this.prisma.station.findMany({ where: { id: { in: stationIds } } });
+        const stationMap = Object.fromEntries(stations.map((s) => [s.id, s]));
+        routeStops = stops.map((s) => ({ sequence: s.sequence, station: stationMap[s.stationId] }));
+      }
+    }
+    // Fall back to the schedule's own TripStopTimes when RouteStop table has no rows
+    // for this route (e.g. route exists but stops were never seeded).
+    if (routeStops.length === 0) {
+      routeStops = (pkg.outboundSchedule.stopTimes ?? [])
+        .filter((st: any) => st.station)
+        .map((st: any) => ({ sequence: st.sequence, station: st.station }));
     }
 
     return {
@@ -382,7 +392,10 @@ export class PackagesService {
   async book(dto: BookPackageDto, passengerId?: string) {
     const pkg = await this.prisma.travelPackage.findUnique({
       where: { id: dto.packageId },
-      include: { priceTiers: true },
+      include: {
+        priceTiers: true,
+        outboundSchedule: { select: { departureAt: true, route: { select: { checkinMinutesBefore: true } } } },
+      },
     });
     if (!pkg) throw new NotFoundException('Package not found');
     if (pkg.status !== 'ACTIVE') throw new BadRequestException('Package is not available for booking');
@@ -440,8 +453,8 @@ export class PackagesService {
           passengerCount,
           adultCount,
           childCount,
-          totalMinor,
-          currency: 'ETB',
+          totalMinor: displayTotalMinor,
+          currency: displayCurrency,
           displayCurrency,
           displayTotalMinor,
           status: 'PENDING_PAYMENT',
@@ -477,6 +490,27 @@ export class PackagesService {
       ]);
     });
 
+    // Extend the seatmap SeatHold (if one was passed) to the payment deadline so the
+    // specific seat remains visually reserved on the seatmap during the full payment
+    // window — matching the behaviour of normal bookings (which call confirmSeats).
+    if (dto.holdId) {
+      const dep = (pkg as any).outboundSchedule?.departureAt as Date | undefined;
+      if (dep) {
+        const checkinMinutes = (pkg as any).outboundSchedule?.route?.checkinMinutesBefore ?? CUTOFF_MINUTES;
+        const paymentDeadline = computePaymentDeadline(booking.createdAt as Date, dep, checkinMinutes);
+        const hold = await this.prisma.seatHold.findUnique({
+          where: { id: dto.holdId },
+          select: { expiresAt: true },
+        });
+        if (hold && paymentDeadline > hold.expiresAt) {
+          await this.prisma.seatHold.update({
+            where: { id: dto.holdId },
+            data: { expiresAt: paymentDeadline },
+          });
+        }
+      }
+    }
+
     return {
       ...booking,
       fareBreakdown: {
diff --git a/apps/edr-passenger-api/src/modules/payments/payment-client.service.ts b/apps/edr-passenger-api/src/modules/payments/payment-client.service.ts
index c9264eeda..84ca92c02 100644
--- a/apps/edr-passenger-api/src/modules/payments/payment-client.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payment-client.service.ts
@@ -12,8 +12,15 @@ import {
   PaymentIntentSnapshot,
   PaymentReferenceType,
   PaymentService,
+  ProviderStatus,
 } from "@edr/types";
 
+/** Side-by-side DB row + live provider status from the payment service diagnostic endpoints. */
+export interface PaymentDiagnostic {
+  db: Record<string, unknown> | null;
+  provider: ProviderStatus | null;
+}
+
 /**
  * Thin HTTP client for the payment microservice (apps/edr-payment-api) — the passenger app's
  * side of the Phase 6 cutover (docs/payment-service §10). Domain validation stays here;
@@ -55,6 +62,28 @@ export class PaymentClientService {
     }
   }
 
+  /**
+   * GET /payments/diagnostic?… — DB intent row + live provider status for a domain reference,
+   * side by side. Returns { db: null, provider: null } when the payment service has no intent.
+   */
+  async getDiagnosticByReference(
+    referenceType: PaymentReferenceType,
+    referenceId: string,
+  ): Promise<PaymentDiagnostic> {
+    const query = new URLSearchParams({
+      service: PaymentService.PASSENGER,
+      referenceType,
+      referenceId,
+    });
+    try {
+      return await this.call("GET", `/payments/diagnostic?${query.toString()}`);
+    } catch (err) {
+      if (err instanceof AxiosError && err.response?.status === 404)
+        return { db: null, provider: null };
+      throw err;
+    }
+  }
+
   /**
    * POST /payments/intents/:id/confirm — submit an OTP for a COLLECT_OTP provider (CAC Bank).
    * A wrong/expired OTP comes back as 400 from the payment service; surface that as a
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 9a0288656..88510f1a5 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.controller.ts
@@ -133,6 +133,33 @@ export class PaymentsController {
     return this.service.getIntentByBookingId(bookingId);
   }
 
+  @Get("status/:bookingRefOrId")
+  @SetMetadata("isPublic", true)
+  @ApiOperation({
+    summary: "Get payment status by booking id or booking reference (PNR)",
+    description:
+      "Accepts either a booking UUID or a booking reference / PNR (e.g. EDR-20240001), " +
+      "resolves it to the booking, and returns the authoritative payment status pulled from " +
+      "the payment microservice.",
+  })
+  getStatusByBookingRefOrId(@Param("bookingRefOrId") bookingRefOrId: string) {
+    return this.service.getIntentByBookingRefOrId(bookingRefOrId);
+  }
+
+  @Get("diagnostic/:bookingRefOrId")
+  @SetMetadata("isPublic", true)
+  @ApiOperation({
+    summary:
+      "Get { db, provider } by booking id or booking reference (PNR) — diagnostic",
+    description:
+      "Accepts a booking UUID or a booking reference / PNR (e.g. EDR-20240001), resolves it to " +
+      "the booking, and returns { db, provider }: the payment service's stored intent row and a " +
+      "live provider status query, side by side. Pure read — does not reconcile the booking.",
+  })
+  getPaymentDiagnostic(@Param("bookingRefOrId") bookingRefOrId: string) {
+    return this.service.getPaymentDiagnosticByBookingRefOrId(bookingRefOrId);
+  }
+
   @Post(":bookingId/confirm")
   @SetMetadata("isPublic", true)
   @ApiOperation({
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.e2e-spec.ts b/apps/edr-passenger-api/src/modules/payments/payments.e2e-spec.ts
index 5393696bf..058b2f9f6 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.e2e-spec.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.e2e-spec.ts
@@ -118,6 +118,7 @@ describe("Payments E2E", () => {
       data: {
         bookingId: booking.id,
         seatId: seat.id,
+        scheduleId: schedule.id,
         passengerName: "Test Passenger",
       },
     });
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 a9e4557f1..e57d94643 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
@@ -24,7 +24,10 @@ import {
   ForceConfirmDto,
 } from "./payments.dto";
 import { PaymentEventDto, MarkPaidResponseDto } from "./internal-payments.dto";
-import { PaymentClientService } from "./payment-client.service";
+import {
+  PaymentClientService,
+  PaymentDiagnostic,
+} from "./payment-client.service";
 import { CurrencyService } from "../currency/currency.service";
 import { AuditService } from "../../common/audit.service";
 import { rebaseUrlOrigin } from "../../common/utils/redirect-origin.util";
@@ -534,6 +537,51 @@ export class PaymentsService {
     };
   }
 
+  /**
+   * Payment status by booking id (UUID) OR booking reference / PNR (e.g. EDR-20240001).
+   * Resolves the PNR to its booking id, then pulls the authoritative status from the payment
+   * microservice (via {@link getIntentByBookingId}).
+   */
+  async getIntentByBookingRefOrId(
+    bookingRefOrId: string,
+  ): Promise<IntentStatusDto> {
+    const bookingId = await this.resolveBookingId(bookingRefOrId);
+    return this.getIntentByBookingId(bookingId);
+  }
+
+  /**
+   * Diagnostic view by booking id (UUID) OR booking reference / PNR: the payment service's
+   * stored intent row and a live provider status query, side by side ({ db, provider }).
+   * Pure read — does not reconcile or confirm the booking.
+   */
+  async getPaymentDiagnosticByBookingRefOrId(
+    bookingRefOrId: string,
+  ): Promise<PaymentDiagnostic> {
+    const bookingId = await this.resolveBookingId(bookingRefOrId);
+    return this.paymentClient.getDiagnosticByReference(
+      PaymentReferenceType.BOOKING,
+      bookingId,
+    );
+  }
+
+  /** Accept a booking UUID as-is; otherwise look the id up from its bookingRef/PNR. */
+  private async resolveBookingId(bookingRefOrId: string): Promise<string> {
+    const isUuid =
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(
+        bookingRefOrId,
+      );
+    if (isUuid) return bookingRefOrId;
+
+    const booking = await this.prisma.booking.findUnique({
+      where: { bookingRef: bookingRefOrId },
+      select: { id: true },
+    });
+    if (!booking) {
+      throw new NotFoundException(`Booking not found: ${bookingRefOrId}`);
+    }
+    return booking.id;
+  }
+
   async getIntentByBookingId(bookingId: string): Promise<IntentStatusDto> {
     const local = await this.prisma.paymentIntent.findUnique({
       where: { bookingId },
diff --git a/apps/edr-passenger-api/src/modules/reports/reports.controller.ts b/apps/edr-passenger-api/src/modules/reports/reports.controller.ts
index a4da5b208..7d832b8c9 100644
--- a/apps/edr-passenger-api/src/modules/reports/reports.controller.ts
+++ b/apps/edr-passenger-api/src/modules/reports/reports.controller.ts
@@ -1,38 +1,50 @@
-import { Body, Controller, Get, Param, Post, Query } from '@nestjs/common';
-import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
-import { ReportsService } from './reports.service';
-import { GenerateReportDto } from './reports.dto';
-import { PassengerStaff } from '../../common/passenger-guards';
-import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
+import { Body, Controller, Get, Param, Post, Query } from "@nestjs/common";
+import { ApiTags, ApiOperation, ApiBearerAuth } from "@nestjs/swagger";
+import { ReportsService } from "./reports.service";
+import { GenerateReportDto } from "./reports.dto";
+import { PassengerStaff } from "../../common/passenger-guards";
+import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
 
-@ApiTags('Reports')
-@Controller('reports')
+@ApiTags("Reports")
+@Controller("reports")
 @PassengerStaff([PASSENGER_PERMS.reports.view, PASSENGER_PERMS.admin])
-@ApiBearerAuth('IAM-auth')
+@ApiBearerAuth("IAM-auth")
 export class ReportsController {
   constructor(private service: ReportsService) {}
 
-  @Post('generate')
-  @ApiOperation({ summary: 'Generate operational report' })
+  @Post("generate")
+  @ApiOperation({ summary: "Generate operational report" })
   generateReport(@Body() dto: GenerateReportDto) {
     return this.service.generateReport(dto);
   }
 
-  @Get('passengers')
-  @ApiOperation({ summary: 'Passengers report for a specific schedule' })
-  getOccupancyReport(@Query('scheduleId') scheduleId: string) {
+  @Get("schedules")
+  @ApiOperation({ summary: "List schedules for the passengers report picker" })
+  listSchedulesForPicker() {
+    return this.service.listSchedulesForPicker();
+  }
+
+  @Get("passengers/list")
+  @ApiOperation({ summary: "Flat passenger list for a specific schedule" })
+  getPassengerList(@Query("scheduleId") scheduleId: string) {
+    return this.service.getPassengerList(scheduleId);
+  }
+
+  @Get("passengers")
+  @ApiOperation({ summary: "Passengers report for a specific schedule" })
+  getOccupancyReport(@Query("scheduleId") scheduleId: string) {
     return this.service.getOccupancyBySchedule(scheduleId);
   }
 
-  @Get(':reportId')
-  @ApiOperation({ summary: 'Get report by ID' })
-  getReport(@Param('reportId') reportId: string) {
+  @Get(":reportId")
+  @ApiOperation({ summary: "Get report by ID" })
+  getReport(@Param("reportId") reportId: string) {
     return this.service.getReport(reportId);
   }
 
   @Get()
-  @ApiOperation({ summary: 'List reports' })
-  listReports(@Query('type') type?: string) {
+  @ApiOperation({ summary: "List reports" })
+  listReports(@Query("type") type?: string) {
     return this.service.listReports(type);
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/reports/reports.service.ts b/apps/edr-passenger-api/src/modules/reports/reports.service.ts
index 12f48b41f..5730fb7ee 100644
--- a/apps/edr-passenger-api/src/modules/reports/reports.service.ts
+++ b/apps/edr-passenger-api/src/modules/reports/reports.service.ts
@@ -1,8 +1,8 @@
-import { Injectable, Logger } from '@nestjs/common';
-import { InjectDataSource } from '@nestjs/typeorm';
-import { DataSource } from 'typeorm';
-import { PrismaService } from '../../common/prisma.service';
-import { GenerateReportDto, ReportType } from './reports.dto';
+import { Injectable, Logger } from "@nestjs/common";
+import { InjectDataSource } from "@nestjs/typeorm";
+import { DataSource } from "typeorm";
+import { PrismaService } from "../../common/prisma.service";
+import { GenerateReportDto, ReportType } from "./reports.dto";
 
 @Injectable()
 export class ReportsService {
@@ -15,7 +15,7 @@ export class ReportsService {
   async generateReport(dto: GenerateReportDto) {
     const dateFrom = new Date(dto.dateFrom);
     dateFrom.setHours(0, 0, 0, 0);
-    
+
     const dateTo = new Date(dto.dateTo);
     dateTo.setHours(23, 59, 59, 999);
 
@@ -28,7 +28,11 @@ export class ReportsService {
         data = await this.generateOccupancyReport(dateFrom, dateTo);
         break;
       case ReportType.AGENT_SALES:
-        data = await this.generateAgentSalesReport(dateFrom, dateTo, dto.agentId);
+        data = await this.generateAgentSalesReport(
+          dateFrom,
+          dateTo,
+          dto.agentId,
+        );
         break;
       case ReportType.CANCELLATIONS:
         data = await this.generateCancellationsReport(dateFrom, dateTo);
@@ -45,8 +49,8 @@ export class ReportsService {
         reportType: dto.reportType,
         dateFrom,
         dateTo,
-        data
-      }
+        data,
+      },
     });
 
     return { reportId: report.id, reportType: dto.reportType, data };
@@ -56,37 +60,43 @@ export class ReportsService {
     // Fetch all bookings in date range, regardless of status
     const bookings = await this.prisma.booking.findMany({
       where: {
-        createdAt: { gte: dateFrom, lte: dateTo }
+        createdAt: { gte: dateFrom, lte: dateTo },
       },
-      include: { paymentIntent: true }
+      include: { paymentIntent: true },
     });
 
     const totalRevenue = bookings.reduce((sum, b) => sum + b.totalMinor, 0);
-    const byPaymentMethod = bookings.reduce((acc, b) => {
-      const method = b.paymentIntent?.method ?? 'UNKNOWN';
-      acc[method] = (acc[method] || 0) + b.totalMinor;
-      return acc;
-    }, {} as Record<string, number>);
+    const byPaymentMethod = bookings.reduce(
+      (acc, b) => {
+        const method = b.paymentIntent?.method ?? "UNKNOWN";
+        acc[method] = (acc[method] || 0) + b.totalMinor;
+        return acc;
+      },
+      {} as Record<string, number>,
+    );
 
     // Group by date for charts
-    const byDate = bookings.reduce((acc, b) => {
-      const date = b.createdAt.toISOString().split('T')[0];
-      if (!acc[date]) {
-        acc[date] = { totalMinor: 0, count: 0 };
-      }
-      acc[date].totalMinor += b.totalMinor;
-      acc[date].count += 1;
-      return acc;
-    }, {} as Record<string, any>);
+    const byDate = bookings.reduce(
+      (acc, b) => {
+        const date = b.createdAt.toISOString().split("T")[0];
+        if (!acc[date]) {
+          acc[date] = { totalMinor: 0, count: 0 };
+        }
+        acc[date].totalMinor += b.totalMinor;
+        acc[date].count += 1;
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
 
     return {
       totalBookings: bookings.length,
       totalRevenueMinor: totalRevenue,
       totalRevenue: totalRevenue / 100,
-      currency: 'ETB',
+      currency: "ETB",
       byPaymentMethod,
       byDate,
-      cancellationRate: 0
+      cancellationRate: 0,
     };
   }
 
@@ -95,75 +105,116 @@ export class ReportsService {
       where: { departureAt: { gte: dateFrom, lte: dateTo } },
       include: {
         coachAssignments: { include: { coach: { include: { seats: true } } } },
-        bookings: { include: { seats: true } },
+        bookings: {
+          where: { status: { in: ["CONFIRMED", "BOARDED"] } },
+          include: { seats: true },
+        },
       },
     });
 
-    const tripData = schedules.map(schedule => {
-      const totalSeats = schedule.coachAssignments.reduce((sum, a) => sum + a.coach.seats.length, 0);
-      const bookedSeats = schedule.bookings.reduce((sum, b) => sum + b.seats.length, 0);
-      const occupancyRate = totalSeats > 0 ? (bookedSeats / totalSeats) * 100 : 0;
-      return { scheduleId: schedule.id, departureAt: schedule.departureAt, totalSeats, bookedSeats, occupancyRate: +occupancyRate.toFixed(2) };
+    const tripData = schedules.map((schedule) => {
+      const totalSeats = schedule.coachAssignments.reduce(
+        (sum, a) => sum + a.coach.seats.length,
+        0,
+      );
+      const bookedSeats = schedule.bookings.reduce(
+        (sum, b) =>
+          sum + b.seats.filter((s: any) => s.scheduleId === schedule.id).length,
+        0,
+      );
+      const occupancyRate =
+        totalSeats > 0 ? (bookedSeats / totalSeats) * 100 : 0;
+      return {
+        scheduleId: schedule.id,
+        departureAt: schedule.departureAt,
+        totalSeats,
+        bookedSeats,
+        occupancyRate: +occupancyRate.toFixed(2),
+      };
     });
 
-    const avgOccupancy = tripData.length > 0 ? tripData.reduce((sum, t) => sum + t.occupancyRate, 0) / tripData.length : 0;
-    return { totalSchedules: schedules.length, averageOccupancyRate: +avgOccupancy.toFixed(2), schedules: tripData };
+    const avgOccupancy =
+      tripData.length > 0
+        ? tripData.reduce((sum, t) => sum + t.occupancyRate, 0) /
+          tripData.length
+        : 0;
+    return {
+      totalSchedules: schedules.length,
+      averageOccupancyRate: +avgOccupancy.toFixed(2),
+      schedules: tripData,
+    };
   }
 
-  private async generateAgentSalesReport(dateFrom: Date, dateTo: Date, agentId?: string) {
+  private async generateAgentSalesReport(
+    dateFrom: Date,
+    dateTo: Date,
+    agentId?: string,
+  ) {
     const agentBookings = await this.prisma.agentBooking.findMany({
       where: {
         createdAt: { gte: dateFrom, lte: dateTo },
-        ...(agentId ? { agentId } : {})
+        ...(agentId ? { agentId } : {}),
       },
       include: {
         agent: { select: { id: true, iamUserId: true, agentCode: true } },
-        booking: true
-      }
+        booking: true,
+      },
     });
 
-    const iamUserIds = [...new Set(
-      agentBookings.map(ab => ab.agent.iamUserId).filter(Boolean) as string[]
-    )];
-    const iamRows = iamUserIds.length > 0
-      ? await this.dataSource.query<{ id: string; name: { en?: string; am?: string } | null }[]>(
-          `SELECT id, name FROM iam.users WHERE id = ANY($1)`,
-          [iamUserIds],
-        )
-      : [];
-    const iamMap = new Map(iamRows.map(r => [r.id, r]));
+    const iamUserIds = [
+      ...new Set(
+        agentBookings
+          .map((ab) => ab.agent.iamUserId)
+          .filter(Boolean) as string[],
+      ),
+    ];
+    const iamRows =
+      iamUserIds.length > 0
+        ? await this.dataSource.query<
+            { id: string; name: { en?: string; am?: string } | null }[]
+          >(`SELECT id, name FROM iam.users WHERE id = ANY($1)`, [iamUserIds])
+        : [];
+    const iamMap = new Map(iamRows.map((r) => [r.id, r]));
 
-    const byAgent = agentBookings.reduce((acc, ab) => {
-      const iam = ab.agent.iamUserId ? iamMap.get(ab.agent.iamUserId) : undefined;
-      const agentName = iam?.name?.en ?? iam?.name?.am ?? ab.agent.agentCode;
-      if (!acc[agentName]) {
-        acc[agentName] = { bookings: 0, revenueMinor: 0, cashCollected: 0 };
-      }
-      acc[agentName].bookings += 1;
-      acc[agentName].revenueMinor += ab.booking.totalMinor;
-      acc[agentName].cashCollected += ab.cashReceived ?? 0;
-      return acc;
-    }, {} as Record<string, any>);
+    const byAgent = agentBookings.reduce(
+      (acc, ab) => {
+        const iam = ab.agent.iamUserId
+          ? iamMap.get(ab.agent.iamUserId)
+          : undefined;
+        const agentName = iam?.name?.en ?? iam?.name?.am ?? ab.agent.agentCode;
+        if (!acc[agentName]) {
+          acc[agentName] = { bookings: 0, revenueMinor: 0, cashCollected: 0 };
+        }
+        acc[agentName].bookings += 1;
+        acc[agentName].revenueMinor += ab.booking.totalMinor;
+        acc[agentName].cashCollected += ab.cashReceived ?? 0;
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
 
     return {
       totalAgentBookings: agentBookings.length,
-      byAgent
+      byAgent,
     };
   }
 
   private async generateCancellationsReport(dateFrom: Date, dateTo: Date) {
     const cancellations = await this.prisma.bookingCancellation.findMany({
       where: { createdAt: { gte: dateFrom, lte: dateTo } },
-      include: { booking: true }
+      include: { booking: true },
     });
 
-    const totalRefunded = cancellations.reduce((sum, c) => sum + c.refundAmount, 0);
+    const totalRefunded = cancellations.reduce(
+      (sum, c) => sum + c.refundAmount,
+      0,
+    );
 
     return {
       totalCancellations: cancellations.length,
       totalRefundedMinor: totalRefunded,
       totalRefunded: totalRefunded / 100,
-      currency: 'ETB'
+      currency: "ETB",
     };
   }
 
@@ -171,23 +222,26 @@ export class ReportsService {
     const payments = await this.prisma.paymentIntent.findMany({
       where: {
         createdAt: { gte: dateFrom, lte: dateTo },
-        status: 'SUCCEEDED'
-      }
+        status: "SUCCEEDED",
+      },
     });
 
-    const byMethod = payments.reduce((acc, p) => {
-      const method = p.method;
-      if (!acc[method]) {
-        acc[method] = { count: 0, totalMinor: 0 };
-      }
-      acc[method].count += 1;
-      acc[method].totalMinor += p.amountMinor;
-      return acc;
-    }, {} as Record<string, any>);
+    const byMethod = payments.reduce(
+      (acc, p) => {
+        const method = p.method;
+        if (!acc[method]) {
+          acc[method] = { count: 0, totalMinor: 0 };
+        }
+        acc[method].count += 1;
+        acc[method].totalMinor += p.amountMinor;
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
 
     return {
       totalPayments: payments.length,
-      byMethod
+      byMethod,
     };
   }
 
@@ -209,33 +263,48 @@ export class ReportsService {
           },
         },
         bookings: {
-          where: { status: { in: ['CONFIRMED', 'BOARDED'] } },
+          where: { status: { in: ["CONFIRMED", "BOARDED"] } },
           include: {
             seats: {
+              where: { leg: 1 },
               include: {
                 seat: { include: { coach: { include: { coachType: true } } } },
               },
             },
           },
         },
-        stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
+        stopTimes: { include: { station: true }, orderBy: { sequence: "asc" } },
       },
     });
 
     if (!schedule) return null;
 
-    const totalSeats = (schedule as any).coachAssignments.reduce((s: number, a: any) => s + a.coach.seats.length, 0);
-    const allBookingSeats = (schedule as any).bookings.flatMap((b: any) => b.seats);
+    const totalSeats = (schedule as any).coachAssignments.reduce(
+      (s: number, a: any) => s + a.coach.seats.length,
+      0,
+    );
+    const allBookingSeats = (schedule as any).bookings.flatMap(
+      (b: any) => b.seats,
+    );
     const totalPassengers = allBookingSeats.length;
-    const occupancyRate = totalSeats > 0 ? +((totalPassengers / totalSeats) * 100).toFixed(1) : 0;
+    const occupancyRate =
+      totalSeats > 0 ? +((totalPassengers / totalSeats) * 100).toFixed(1) : 0;
 
     // Per-coach breakdown
-    const coachMap = new Map<string, { coachNumber: string; coachType: string; totalSeats: number; booked: number }>();
+    const coachMap = new Map<
+      string,
+      {
+        coachNumber: string;
+        coachType: string;
+        totalSeats: number;
+        booked: number;
+      }
+    >();
     for (const assignment of (schedule as any).coachAssignments) {
       const c = assignment.coach;
       coachMap.set(c.id, {
         coachNumber: c.number,
-        coachType: (c as any).coachType?.name ?? 'Unknown',
+        coachType: (c as any).coachType?.name ?? "Unknown",
         totalSeats: c.seats.length,
         booked: 0,
       });
@@ -244,56 +313,91 @@ export class ReportsService {
       const coachId = bs.seat?.coachId;
       if (coachId && coachMap.has(coachId)) coachMap.get(coachId)!.booked++;
     }
-    const byCoach = [...coachMap.values()].map(c => ({
+    const byCoach = [...coachMap.values()].map((c) => ({
       ...c,
-      occupancyRate: c.totalSeats > 0 ? +((c.booked / c.totalSeats) * 100).toFixed(1) : 0,
+      occupancyRate:
+        c.totalSeats > 0 ? +((c.booked / c.totalSeats) * 100).toFixed(1) : 0,
     }));
 
     // Per-origin station breakdown (using booking's originStationId)
-    const originMap = new Map<string, { stationName: string; passengers: number }>();
+    const originMap = new Map<
+      string,
+      { stationName: string; passengers: number }
+    >();
     for (const booking of (schedule as any).bookings) {
       const stationId = booking.originStationId ?? schedule.originStationId;
-      const stationName = (schedule as any).stopTimes.find((st: any) => st.stationId === stationId)?.station?.name
-        ?? (schedule as any).originStation?.name
-        ?? stationId;
-      if (!originMap.has(stationId)) originMap.set(stationId, { stationName, passengers: 0 });
+      const stationName =
+        (schedule as any).stopTimes.find(
+          (st: any) => st.stationId === stationId,
+        )?.station?.name ??
+        (schedule as any).originStation?.name ??
+        stationId;
+      if (!originMap.has(stationId))
+        originMap.set(stationId, { stationName, passengers: 0 });
       originMap.get(stationId)!.passengers += booking.seats.length;
     }
-    const byOrigin = [...originMap.values()].sort((a, b) => b.passengers - a.passengers);
+    const byOrigin = [...originMap.values()].sort(
+      (a, b) => b.passengers - a.passengers,
+    );
 
     // Per-destination station breakdown
-    const destMap = new Map<string, { stationName: string; passengers: number }>();
+    const destMap = new Map<
+      string,
+      { stationName: string; passengers: number }
+    >();
     for (const booking of (schedule as any).bookings) {
-      const stationId = booking.destinationStationId ?? schedule.destinationStationId;
-      const stationName = (schedule as any).stopTimes.find((st: any) => st.stationId === stationId)?.station?.name
-        ?? (schedule as any).destinationStation?.name
-        ?? stationId;
-      if (!destMap.has(stationId)) destMap.set(stationId, { stationName, passengers: 0 });
+      const stationId =
+        booking.destinationStationId ?? schedule.destinationStationId;
+      const stationName =
+        (schedule as any).stopTimes.find(
+          (st: any) => st.stationId === stationId,
+        )?.station?.name ??
+        (schedule as any).destinationStation?.name ??
+        stationId;
+      if (!destMap.has(stationId))
+        destMap.set(stationId, { stationName, passengers: 0 });
       destMap.get(stationId)!.passengers += booking.seats.length;
     }
-    const byDestination = [...destMap.values()].sort((a, b) => b.passengers - a.passengers);
+    const byDestination = [...destMap.values()].sort(
+      (a, b) => b.passengers - a.passengers,
+    );
 
     // Per-class breakdown
-    const classMap = new Map<string, { className: string; totalSeats: number; booked: number }>();
+    const classMap = new Map<
+      string,
+      { className: string; totalSeats: number; booked: number }
+    >();
     for (const assignment of (schedule as any).coachAssignments) {
-      const typeName = (assignment.coach as any).coachType?.name ?? 'Unknown';
-      if (!classMap.has(typeName)) classMap.set(typeName, { className: typeName, totalSeats: 0, booked: 0 });
+      const typeName = (assignment.coach as any).coachType?.name ?? "Unknown";
+      if (!classMap.has(typeName))
+        classMap.set(typeName, {
+          className: typeName,
+          totalSeats: 0,
+          booked: 0,
+        });
       classMap.get(typeName)!.totalSeats += assignment.coach.seats.length;
     }
     for (const bs of allBookingSeats) {
-      const typeName = bs.seat?.coach?.coachType?.name ?? 'Unknown';
-      if (!classMap.has(typeName)) classMap.set(typeName, { className: typeName, totalSeats: 0, booked: 0 });
+      const typeName = bs.seat?.coach?.coachType?.name ?? "Unknown";
+      if (!classMap.has(typeName))
+        classMap.set(typeName, {
+          className: typeName,
+          totalSeats: 0,
+          booked: 0,
+        });
       classMap.get(typeName)!.booked++;
     }
-    const byClass = [...classMap.values()].map(c => ({
+    const byClass = [...classMap.values()].map((c) => ({
       ...c,
-      occupancyRate: c.totalSeats > 0 ? +((c.booked / c.totalSeats) * 100).toFixed(1) : 0,
+      occupancyRate:
+        c.totalSeats > 0 ? +((c.booked / c.totalSeats) * 100).toFixed(1) : 0,
     }));
 
     return {
       schedule: {
         id: schedule.id,
-        trainName: (schedule as any).train?.name ?? (schedule as any).train?.number,
+        trainName:
+          (schedule as any).train?.name ?? (schedule as any).train?.number,
         origin: (schedule as any).originStation?.name,
         destination: (schedule as any).destinationStation?.name,
         departureAt: schedule.departureAt,
@@ -307,15 +411,197 @@ export class ReportsService {
     };
   }
 
+  async listSchedulesForPicker() {
+    const schedules = await this.prisma.trainSchedule.findMany({
+      select: {
+        id: true,
+        departureAt: true,
+        train: { select: { number: true } },
+        originStation: { select: { name: true } },
+        destinationStation: { select: { name: true } },
+      },
+      orderBy: { departureAt: "desc" },
+      take: 200,
+    });
+    return schedules.map((s) => ({
+      id: s.id,
+      label: `${s.train.number} · ${s.originStation.name} → ${s.destinationStation.name} · ${new Date(s.departureAt).toLocaleString("en-GB", { dateStyle: "medium", timeStyle: "short" })}`,
+    }));
+  }
+
+  async getPassengerList(scheduleId: string) {
+    const seats = await this.prisma.bookingSeat.findMany({
+      where: {
+        leg: 1,
+        booking: { scheduleId, status: { in: ["CONFIRMED", "BOARDED"] } },
+      },
+      include: {
+        booking: {
+          select: {
+            bookingRef: true,
+            status: true,
+            originStationId: true,
+            destinationStationId: true,
+            totalMinor: true,
+            currency: true,
+            _count: { select: { seats: true } },
+          },
+        },
+        seat: { select: { seatNumber: true, bedPosition: true, coach: { select: { number: true, coachType: { select: { name: true, seatClasses: { select: { name: true, bedPosition: true } } } } } } } },
+      },
+      orderBy: [{ seat: { coach: { number: "asc" } } }, { seat: { seatNumber: "asc" } }],
+    });
+
+    const stationIds = [...new Set(
+      seats.flatMap(bs => [bs.booking.originStationId, bs.booking.destinationStationId]).filter(Boolean) as string[],
+    )];
+    const stations = stationIds.length > 0
+      ? await this.prisma.station.findMany({ where: { id: { in: stationIds } }, select: { id: true, name: true } })
+      : [];
+    const stationName = new Map(stations.map(s => [s.id, s.name]));
+
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: scheduleId },
+      select: { departureAt: true },
+    });
+
+    return seats.map((bs) => ({
+      bookingRef: bs.booking.bookingRef,
+      passengerName: bs.passengerName,
+      passengerCategory: bs.passengerCategory,
+      idDocumentType: bs.idDocumentType,
+      idDocumentNumber: bs.idDocumentNumber,
+      passportNumber: bs.passportNumber,
+      passportCountry: bs.passportCountry,
+      seatLabel: bs.seatLabelSnapshot,
+      seatNumber: bs.seat?.seatNumber ?? null,
+      seatClassName: (() => {
+        const classes = bs.seat?.coach?.coachType?.seatClasses ?? [];
+        const matched = bs.seat?.bedPosition
+          ? classes.find((sc: any) => sc.bedPosition?.toLowerCase() === bs.seat!.bedPosition!.toLowerCase())
+          : null;
+        return (matched ?? classes[0])?.name ?? bs.seat?.coach?.coachType?.name ?? null;
+      })(),
+      coachNumber: bs.seat?.coach?.number ?? null,
+      coachType: bs.seat?.coach?.coachType?.name ?? null,
+      nationality: bs.passportCountry
+        ? (bs.passportCountry === 'Djibouti' ? 'Djiboutian' : bs.passportCountry)
+        : bs.idDocumentType === 'NATIONAL_ID' ? 'Ethiopian' : null,
+      origin: bs.booking.originStationId ? (stationName.get(bs.booking.originStationId) ?? null) : null,
+      destination: bs.booking.destinationStationId ? (stationName.get(bs.booking.destinationStationId) ?? null) : null,
+      amountPaidMinor: bs.booking.totalMinor,
+      currency: bs.booking.currency ?? 'ETB',
+      isGroupBooking: (bs.booking._count?.seats ?? 0) > 1,
+      bookingStatus: bs.booking.status,
+    }));
+  }
+
+  async getSeatStatusReport(scheduleId: string) {
+    // Booked seats — exclude dining coaches
+    const bookingSeats = await this.prisma.bookingSeat.findMany({
+      where: {
+        leg: 1,
+        booking: { scheduleId, status: { in: ['CONFIRMED', 'BOARDED', 'PENDING_PAYMENT'] } },
+        seat: { coach: { coachType: { type: { not: 'dining' } } } },
+      },
+      include: {
+        booking: {
+          select: {
+            bookingRef: true,
+            status: true,
+            totalMinor: true,
+            currency: true,
+            createdAt: true,
+            paymentIntent: { select: { status: true } },
+          },
+        },
+        seat: {
+          select: {
+            seatNumber: true,
+            bedPosition: true,
+            coach: {
+              select: {
+                number: true,
+                coachType: { select: { name: true, type: true, seatClasses: { select: { name: true, bedPosition: true } } } },
+              },
+            },
+          },
+        },
+      },
+      orderBy: [{ seat: { coach: { number: 'asc' } } }, { seat: { seatNumber: 'asc' } }],
+    });
+
+    // Manually blocked seats for this schedule — exclude MAINTENANCE entries
+    const blocks = await this.prisma.seatBlock.findMany({
+      where: {
+        scheduleId,
+        NOT: { reason: { startsWith: 'MAINTENANCE:' } },
+      },
+      include: {
+        seat: {
+          select: {
+            seatNumber: true,
+            bedPosition: true,
+            coach: {
+              select: {
+                number: true,
+                coachType: { select: { name: true, type: true, seatClasses: { select: { name: true, bedPosition: true } } } },
+              },
+            },
+          },
+        },
+      },
+      orderBy: { blockedAt: 'desc' },
+    });
+
+    const resolveSeatClass = (seat: any): string | null => {
+      const classes = seat?.coach?.coachType?.seatClasses ?? [];
+      const matched = seat?.bedPosition
+        ? classes.find((sc: any) => sc.bedPosition?.toLowerCase() === seat.bedPosition.toLowerCase())
+        : null;
+      return (matched ?? classes[0])?.name ?? seat?.coach?.coachType?.name ?? null;
+    };
+
+    return {
+      bookedSeats: bookingSeats.map(bs => ({
+        bookingRef: bs.booking.bookingRef,
+        passengerName: bs.passengerName,
+        passengerCategory: bs.passengerCategory,
+        coachNumber: bs.seat?.coach?.number ?? null,
+        seatNumber: bs.seat?.seatNumber ?? null,
+        seatClassName: resolveSeatClass(bs.seat),
+        fareMinor: bs.fareMinor,
+        currency: bs.booking.currency ?? 'ETB',
+        bookingStatus: bs.booking.status,
+        paymentStatus: bs.booking.paymentIntent?.status ?? 'PENDING',
+        bookedAt: bs.booking.createdAt,
+      })),
+      blockedSeats: blocks
+        .filter(b => b.seat?.coach?.coachType?.type !== 'dining')
+        .map(b => ({
+          id: b.id,
+          coachNumber: b.seat?.coach?.number ?? null,
+          seatNumber: b.seat?.seatNumber ?? null,
+          seatClassName: resolveSeatClass(b.seat),
+          reason: b.reason,
+          blockedBy: b.blockedBy,
+          blockedAt: b.blockedAt,
+          unblockAt: b.unblockAt,
+        })),
+    };
+  }
+
   async getReport(reportId: string) {
-    return this.prisma.operationalReport.findUnique({ where: { id: reportId } });
+    return this.prisma.operationalReport.findUnique({
+      where: { id: reportId },
+    });
   }
 
   async listReports(reportType?: string) {
     return this.prisma.operationalReport.findMany({
       where: reportType ? { reportType } : {},
-      orderBy: { createdAt: 'desc' },
-      take: 50
+      orderBy: { createdAt: "desc" },
+      take: 50,
     });
   }
 }
diff --git a/apps/edr-passenger-api/src/modules/schedules/routes.dto.ts b/apps/edr-passenger-api/src/modules/schedules/routes.dto.ts
index f2db36e7c..fefa26ad1 100644
--- a/apps/edr-passenger-api/src/modules/schedules/routes.dto.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/routes.dto.ts
@@ -7,6 +7,8 @@ export class RouteStopInputDto {
   @ApiProperty({ example: 1, description: 'Stop order (1 = origin, ascending)' }) @IsInt() @Min(1) sequence: number;
   @ApiPropertyOptional({ example: 120.5, description: 'Distance in km from previous stop' }) @IsOptional() @IsNumber() distanceKm?: number;
   @ApiPropertyOptional({ example: 45, description: 'Override check-in cutoff (minutes) for this stop. Falls back to route-level checkinMinutesBefore if omitted.' }) @IsOptional() @IsInt() @Min(1) checkinMinutesBefore?: number;
+  @ApiPropertyOptional({ example: '2026-06-15T06:30:00Z', description: 'Template planned arrival time at this stop. Only the time-of-day (EAT) is used when auto-populating new schedules. Omit for first stop.' }) @IsOptional() @IsDateString() plannedArrivalTime?: string;
+  @ApiPropertyOptional({ example: '2026-06-15T06:45:00Z', description: 'Template planned departure time from this stop. Only the time-of-day (EAT) is used when auto-populating new schedules. Omit for last stop.' }) @IsOptional() @IsDateString() plannedDepartureTime?: string;
 }
 
 export class CreateRouteDto {
@@ -37,6 +39,8 @@ export class AddRouteStopDto {
   @ApiProperty({ example: 3 }) @IsInt() @Min(1) sequence: number;
   @ApiPropertyOptional({ example: 75.5 }) @IsOptional() @IsNumber() distanceKm?: number;
   @ApiPropertyOptional({ example: 45, description: 'Override check-in cutoff (minutes) for this stop. Falls back to route-level checkinMinutesBefore if omitted.' }) @IsOptional() @IsInt() @Min(1) checkinMinutesBefore?: number;
+  @ApiPropertyOptional({ example: '2026-06-15T06:30:00Z', description: 'Template planned arrival time at this stop (only time-of-day is used)' }) @IsOptional() @IsDateString() plannedArrivalTime?: string;
+  @ApiPropertyOptional({ example: '2026-06-15T06:45:00Z', description: 'Template planned departure time from this stop (only time-of-day is used)' }) @IsOptional() @IsDateString() plannedDepartureTime?: string;
 }
 
 export class UpdateRouteDto {
diff --git a/apps/edr-passenger-api/src/modules/schedules/routes.service.ts b/apps/edr-passenger-api/src/modules/schedules/routes.service.ts
index 58e647180..dcbdbc3b0 100644
--- a/apps/edr-passenger-api/src/modules/schedules/routes.service.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/routes.service.ts
@@ -37,6 +37,8 @@ export class RoutesService {
             sequence: s.sequence,
             distanceKm: s.distanceKm != null ? parseFloat(String(s.distanceKm)) : null,
             checkinMinutesBefore: s.checkinMinutesBefore ?? null,
+            plannedArrivalTime: s.plannedArrivalTime ? new Date(s.plannedArrivalTime) : null,
+            plannedDepartureTime: s.plannedDepartureTime ? new Date(s.plannedDepartureTime) : null,
           })),
         },
       },
@@ -106,6 +108,8 @@ export class RoutesService {
           sequence: s.sequence,
           distanceKm: s.distanceKm != null ? parseFloat(String(s.distanceKm)) : null,
           checkinMinutesBefore: s.checkinMinutesBefore ?? null,
+          plannedArrivalTime: s.plannedArrivalTime ?? null,
+          plannedDepartureTime: s.plannedDepartureTime ?? null,
         })),
       });
     }
@@ -225,6 +229,8 @@ export class RoutesService {
         sequence: dto.sequence,
         distanceKm: dto.distanceKm != null ? parseFloat(String(dto.distanceKm)) : null,
         checkinMinutesBefore: dto.checkinMinutesBefore ?? null,
+        plannedArrivalTime: dto.plannedArrivalTime ?? null,
+        plannedDepartureTime: dto.plannedDepartureTime ?? null,
       },
     });
   }
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 5a648307d..12f918edd 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.dto.ts
@@ -65,6 +65,9 @@ export class UpdateScheduleDto {
   @ApiPropertyOptional({ enum: TripStatus, example: TripStatus.SCHEDULED }) @IsOptional() @IsEnum(TripStatus) status?: TripStatus;
   @ApiPropertyOptional({ type: [CoachAssignmentDto], description: 'List of coaches to assign' }) @IsOptional() @IsArray() @ValidateNested({ each: true }) @Type(() => CoachAssignmentDto) coaches?: CoachAssignmentDto[];
   @ApiPropertyOptional({ example: false, description: 'Exclude from public search (reserved for packages)' }) @IsOptional() isPackageOnly?: boolean;
+  @ApiPropertyOptional({ type: [PlannedStopTimeDto], description: 'Planned times per stop — when provided, replaces all existing stop times for the schedule' })
+  @IsOptional() @IsArray() @ValidateNested({ each: true }) @Type(() => PlannedStopTimeDto)
+  plannedTimes?: PlannedStopTimeDto[];
 }
 
 export class UpdateStopTimeDto {
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 7cca548aa..ecdf51666 100644
--- a/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
+++ b/apps/edr-passenger-api/src/modules/schedules/schedules.service.ts
@@ -133,26 +133,62 @@ export class SchedulesService {
 
     let plannedTimes = dto.plannedTimes;
     if (!plannedTimes || plannedTimes.length === 0) {
-      const totalDuration = arr.getTime() - dep.getTime();
-      const totalDistance = route.stops[route.stops.length - 1].distanceKm || 0;
+      const hasRouteTimes = route.stops.some(
+        s => (s as any).plannedArrivalTime != null || (s as any).plannedDepartureTime != null,
+      );
 
-      plannedTimes = route.stops.map((stop, index) => {
-        let stopTime: Date;
-        if (index === 0) {
-          stopTime = dep;
-        } else if (index === route.stops.length - 1) {
-          stopTime = arr;
-        } else {
-          const stopDistance = stop.distanceKm || 0;
-          const progress = totalDistance > 0 ? stopDistance / totalDistance : index / (route.stops.length - 1);
-          stopTime = new Date(dep.getTime() + totalDuration * progress);
-        }
-        return {
-          sequence: stop.sequence,
-          plannedArrivalAt: index === 0 ? undefined : stopTime.toISOString(),
-          plannedDepartureAt: index === route.stops.length - 1 ? undefined : stopTime.toISOString(),
+      if (hasRouteTimes) {
+        // Extract EAT time-of-day from a template DateTime and anchor to the schedule's EAT date.
+        const EAT_MS = 3 * 60 * 60 * 1000;
+        const depEATMs = dep.getTime() + EAT_MS;
+        const depMsIntoDay = depEATMs % (24 * 60 * 60 * 1000);
+        const eatMidnightUTC = dep.getTime() - depMsIntoDay;
+
+        const templateToScheduleUTC = (templateDt: Date): Date => {
+          // Pull the time-of-day in EAT from the template DateTime
+          const templateEATMs = templateDt.getTime() + EAT_MS;
+          const timeOfDayMs = templateEATMs % (24 * 60 * 60 * 1000);
+          const candidate = new Date(eatMidnightUTC + timeOfDayMs);
+          // Overnight: if the stop time lands before departure, move to next day
+          if (candidate < dep) return new Date(candidate.getTime() + 24 * 60 * 60 * 1000);
+          return candidate;
         };
-      });
+
+        plannedTimes = route.stops.map((stop, index) => {
+          const arrDt: Date | null = (stop as any).plannedArrivalTime ?? null;
+          const depDt: Date | null = (stop as any).plannedDepartureTime ?? null;
+          return {
+            sequence: stop.sequence,
+            plannedArrivalAt: index > 0 && arrDt != null
+              ? templateToScheduleUTC(arrDt).toISOString()
+              : undefined,
+            plannedDepartureAt: index < route.stops.length - 1 && depDt != null
+              ? templateToScheduleUTC(depDt).toISOString()
+              : undefined,
+          };
+        });
+      } else {
+        const totalDuration = arr.getTime() - dep.getTime();
+        const totalDistance = route.stops[route.stops.length - 1].distanceKm || 0;
+
+        plannedTimes = route.stops.map((stop, index) => {
+          let stopTime: Date;
+          if (index === 0) {
+            stopTime = dep;
+          } else if (index === route.stops.length - 1) {
+            stopTime = arr;
+          } else {
+            const stopDistance = stop.distanceKm || 0;
+            const progress = totalDistance > 0 ? stopDistance / totalDistance : index / (route.stops.length - 1);
+            stopTime = new Date(dep.getTime() + totalDuration * progress);
+          }
+          return {
+            sequence: stop.sequence,
+            plannedArrivalAt: index === 0 ? undefined : stopTime.toISOString(),
+            plannedDepartureAt: index === route.stops.length - 1 ? undefined : stopTime.toISOString(),
+          };
+        });
+      }
     }
 
     const providedSeqs = new Set((plannedTimes ?? []).map(t => t.sequence));
@@ -304,26 +340,59 @@ export class SchedulesService {
 
     let plannedTimes = dto.plannedTimes;
     if (!plannedTimes || plannedTimes.length === 0) {
-      const totalDuration = arr.getTime() - dep.getTime();
-      const totalDistance = route.stops[route.stops.length - 1].distanceKm || 0;
+      const hasRouteTimes = route.stops.some(
+        s => (s as any).plannedArrivalTime != null || (s as any).plannedDepartureTime != null,
+      );
 
-      plannedTimes = route.stops.map((stop, index) => {
-        let stopTime: Date;
-        if (index === 0) {
-          stopTime = dep;
-        } else if (index === route.stops.length - 1) {
-          stopTime = arr;
-        } else {
-          const stopDistance = stop.distanceKm || 0;
-          const progress = totalDistance > 0 ? stopDistance / totalDistance : index / (route.stops.length - 1);
-          stopTime = new Date(dep.getTime() + totalDuration * progress);
-        }
-        return {
-          sequence: stop.sequence,
-          plannedArrivalAt: index === 0 ? undefined : stopTime.toISOString(),
-          plannedDepartureAt: index === route.stops.length - 1 ? undefined : stopTime.toISOString(),
+      if (hasRouteTimes) {
+        const EAT_MS = 3 * 60 * 60 * 1000;
+        const depEATMs = dep.getTime() + EAT_MS;
+        const depMsIntoDay = depEATMs % (24 * 60 * 60 * 1000);
+        const eatMidnightUTC = dep.getTime() - depMsIntoDay;
+
+        const templateToScheduleUTC = (templateDt: Date): Date => {
+          const templateEATMs = templateDt.getTime() + EAT_MS;
+          const timeOfDayMs = templateEATMs % (24 * 60 * 60 * 1000);
+          const candidate = new Date(eatMidnightUTC + timeOfDayMs);
+          if (candidate < dep) return new Date(candidate.getTime() + 24 * 60 * 60 * 1000);
+          return candidate;
         };
-      });
+
+        plannedTimes = route.stops.map((stop, index) => {
+          const arrDt: Date | null = (stop as any).plannedArrivalTime ?? null;
+          const depDt: Date | null = (stop as any).plannedDepartureTime ?? null;
+          return {
+            sequence: stop.sequence,
+            plannedArrivalAt: index > 0 && arrDt != null
+              ? templateToScheduleUTC(arrDt).toISOString()
+              : undefined,
+            plannedDepartureAt: index < route.stops.length - 1 && depDt != null
+              ? templateToScheduleUTC(depDt).toISOString()
+              : undefined,
+          };
+        });
+      } else {
+        const totalDuration = arr.getTime() - dep.getTime();
+        const totalDistance = route.stops[route.stops.length - 1].distanceKm || 0;
+
+        plannedTimes = route.stops.map((stop, index) => {
+          let stopTime: Date;
+          if (index === 0) {
+            stopTime = dep;
+          } else if (index === route.stops.length - 1) {
+            stopTime = arr;
+          } else {
+            const stopDistance = stop.distanceKm || 0;
+            const progress = totalDistance > 0 ? stopDistance / totalDistance : index / (route.stops.length - 1);
+            stopTime = new Date(dep.getTime() + totalDuration * progress);
+          }
+          return {
+            sequence: stop.sequence,
+            plannedArrivalAt: index === 0 ? undefined : stopTime.toISOString(),
+            plannedDepartureAt: index === route.stops.length - 1 ? undefined : stopTime.toISOString(),
+          };
+        });
+      }
     }
 
     const plannedTimesMap = Object.fromEntries(plannedTimes.map(t => [t.sequence, t]));
@@ -678,6 +747,12 @@ export class SchedulesService {
       }
     }
 
+    if (dto.plannedTimes && dto.plannedTimes.length > 0 && schedule.routeId) {
+      await this.prisma.tripStopTime.deleteMany({ where: { scheduleId: id } });
+      const plannedTimesMap = Object.fromEntries(dto.plannedTimes.map(t => [t.sequence, t]));
+      await this.routesService.applyRouteToSchedule(schedule.routeId, id, plannedTimesMap);
+    }
+
     return this.getSchedule(id);
   }
 
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 a51dc0142..6ed657975 100644
--- a/apps/edr-passenger-api/src/modules/search/search.service.ts
+++ b/apps/edr-passenger-api/src/modules/search/search.service.ts
@@ -1,11 +1,16 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
-import { PrismaService } from '../../common/prisma.service';
-import { SearchTripsDto, FareQuoteDto, FareBreakdownRequestDto, FareBreakdownPassengerDto } from './search.dto';
-import { CurrencyService } from '../currency/currency.service';
-import { FareEngineService } from '../fare-engine/fare-engine.service';
-import { SegmentsService } from '../segments/segments.service';
-import { resolveCurrencyFromNationality } from '../fare-engine/fare-engine.dto';
-import { Currency } from '@prisma/client';
+import { Injectable, NotFoundException } from "@nestjs/common";
+import { PrismaService } from "../../common/prisma.service";
+import {
+  SearchTripsDto,
+  FareQuoteDto,
+  FareBreakdownRequestDto,
+  FareBreakdownPassengerDto,
+} from "./search.dto";
+import { CurrencyService } from "../currency/currency.service";
+import { FareEngineService } from "../fare-engine/fare-engine.service";
+import { SegmentsService } from "../segments/segments.service";
+import { resolveCurrencyFromNationality } from "../fare-engine/fare-engine.dto";
+import { Currency } from "@prisma/client";
 
 const POINTS_TO_MINOR = 10;
 
@@ -19,19 +24,48 @@ type ScheduleWithIncludes = {
   train: any;
   originStation: any;
   destinationStation: any;
-  route: { checkinMinutesBefore: number; stops: Array<{ stationId: string; checkinMinutesBefore: number | null }> } | null;
-  stopTimes: Array<{ stationId: string; sequence: number; plannedArrivalAt: Date | null; plannedDepartureAt: Date | null; station: any }>;
-  coachAssignments: Array<{ coach: { id: string; seats: any[]; coachType: { id: string; name: string; code: string; seatClasses: any[] } | null } }>;
+  route: {
+    checkinMinutesBefore: number;
+    stops: Array<{ stationId: string; checkinMinutesBefore: number | null }>;
+  } | null;
+  stopTimes: Array<{
+    stationId: string;
+    sequence: number;
+    plannedArrivalAt: Date | null;
+    plannedDepartureAt: Date | null;
+    station: any;
+  }>;
+  coachAssignments: Array<{
+    coach: {
+      id: string;
+      seats: any[];
+      coachType: {
+        id: string;
+        name: string;
+        code: string;
+        seatClasses: any[];
+      } | null;
+    };
+  }>;
 };
 
 const SCHEDULE_INCLUDE = {
   train: true,
   originStation: true,
   destinationStation: true,
-  route: { select: { checkinMinutesBefore: true, stops: { select: { stationId: true, checkinMinutesBefore: true } } } },
-  stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
+  route: {
+    select: {
+      checkinMinutesBefore: true,
+      stops: { select: { stationId: true, checkinMinutesBefore: true } },
+    },
+  },
+  stopTimes: { include: { station: true }, orderBy: { sequence: "asc" } },
   coachAssignments: {
-    include: { coach: { include: { seats: true, coachType: { include: { seatClasses: true } } } } },
+    include: {
+      coach: {
+        include: { seats: true, coachType: { include: { seatClasses: true } } },
+      },
+    },
   },
 } as const;
 
@@ -66,7 +100,7 @@ export class SearchService {
 
     const outbound = [...direct, ...transit];
 
-    if (outbound.length === 0 && dto.journeyType !== 'ROUND_TRIP') {
+    if (outbound.length === 0 && dto.journeyType !== "ROUND_TRIP") {
       const alternativesOutbound = await this.searchAlternatives(
         dto.originStationId,
         dto.destinationStationId,
@@ -76,14 +110,14 @@ export class SearchService {
         dto.nationality,
       );
       return {
-        journeyType: 'ONE_WAY',
+        journeyType: "ONE_WAY",
         outbound: [],
         alternativeOutbound: alternativesOutbound,
         requestedDate: dto.date,
       };
     }
 
-    if (dto.journeyType === 'ROUND_TRIP') {
+    if (dto.journeyType === "ROUND_TRIP") {
       const [returnDirect, returnTransit] = await Promise.all([
         this.searchSchedules(
           dto.destinationStationId,
@@ -104,12 +138,19 @@ export class SearchService {
       ]);
 
       const allReturn = [...returnDirect, ...returnTransit];
-      const latestOutboundArrival = outbound.length > 0
-        ? Math.max(...outbound.map((s: any) => new Date(s.arrivalAt ?? s.leg2?.arrivalAt).getTime()))
-        : Date.now();
+      const latestOutboundArrival =
+        outbound.length > 0
+          ? Math.max(
+              ...outbound.map((s: any) =>
+                new Date(s.arrivalAt ?? s.leg2?.arrivalAt).getTime(),
+              ),
+            )
+          : Date.now();
 
-      const inbound = allReturn.filter((s: any) =>
-        new Date(s.departureAt ?? s.leg1?.departureAt).getTime() > latestOutboundArrival
+      const inbound = allReturn.filter(
+        (s: any) =>
+          new Date(s.departureAt ?? s.leg1?.departureAt).getTime() >
+          latestOutboundArrival,
       );
 
       const returnDate = dto.returnDate ?? dto.date;
@@ -117,14 +158,28 @@ export class SearchService {
       if (outbound.length === 0 || inbound.length === 0) {
         const [alternativeOutbound, alternativeInbound] = await Promise.all([
           outbound.length === 0
-            ? this.searchAlternatives(dto.originStationId, dto.destinationStationId, dto.date, dto.adultCount, dto.childCount, dto.nationality)
+            ? this.searchAlternatives(
+                dto.originStationId,
+                dto.destinationStationId,
+                dto.date,
+                dto.adultCount,
+                dto.childCount,
+                dto.nationality,
+              )
             : Promise.resolve([]),
           inbound.length === 0
-            ? this.searchAlternatives(dto.destinationStationId, dto.originStationId, returnDate, dto.adultCount, dto.childCount, dto.nationality)
+            ? this.searchAlternatives(
+                dto.destinationStationId,
+                dto.originStationId,
+                returnDate,
+                dto.adultCount,
+                dto.childCount,
+                dto.nationality,
+              )
             : Promise.resolve([]),
         ]);
         return {
-          journeyType: 'ROUND_TRIP',
+          journeyType: "ROUND_TRIP",
           outbound,
           inbound,
           alternativeOutbound,
@@ -134,10 +189,16 @@ export class SearchService {
         };
       }
 
-      return { journeyType: 'ROUND_TRIP', outbound, inbound, requestedDate: dto.date, requestedReturnDate: returnDate };
+      return {
+        journeyType: "ROUND_TRIP",
+        outbound,
+        inbound,
+        requestedDate: dto.date,
+        requestedReturnDate: returnDate,
+      };
     }
 
-    return { journeyType: 'ONE_WAY', outbound };
+    return { journeyType: "ONE_WAY", outbound };
   }
 
   private async searchAlternatives(
@@ -148,15 +209,19 @@ export class SearchService {
     childCount?: number,
     nationality?: string,
   ) {
-    const [y, m, d] = dateStr.split('-').map(Number);
-    const requestedDate = new Date(y, m - 1, d, 0, 0, 0, 0);
-    const requestedNextDay = new Date(y, m - 1, d + 1, 0, 0, 0, 0);
+    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`,
+    );
     const now = new Date();
     const totalPassengers = adultCount + (childCount ?? 0);
     const NEEDED = 3;
 
     const baseWhere = {
-      status: 'SCHEDULED',
+      status: "SCHEDULED",
       isPackageOnly: false,
       stopTimes: { some: { stationId: originStationId } },
       coachAssignments: { some: {} },
@@ -168,24 +233,44 @@ export class SearchService {
 
     const [beforeCandidates, afterCandidates] = await Promise.all([
       this.prisma.trainSchedule.findMany({
-        where: { ...baseWhere, departureAt: { gte: now < requestedDate ? now : new Date(0), lt: requestedDate } },
+        where: {
+          ...baseWhere,
+          departureAt: {
+            gte: now < requestedDate ? now : new Date(0),
+            lt: requestedDate,
+          },
+        },
         include: SCHEDULE_INCLUDE,
-        orderBy: { departureAt: 'desc' },
+        orderBy: { departureAt: "desc" },
         take: FETCH_LIMIT,
       }),
       this.prisma.trainSchedule.findMany({
-        where: { ...baseWhere, departureAt: { gte: requestedNextDay > now ? requestedNextDay : now } },
+        where: {
+          ...baseWhere,
+          departureAt: { gte: requestedNextDay > now ? requestedNextDay : now },
+        },
         include: SCHEDULE_INCLUDE,
-        orderBy: { departureAt: 'asc' },
+        orderBy: { departureAt: "asc" },
         take: FETCH_LIMIT,
       }),
     ]);
 
-    const pickN = async (candidates: typeof beforeCandidates, limit: number) => {
-      const out: NonNullable<Awaited<ReturnType<typeof this.buildScheduleResult>>>[] = [];
+    const pickN = async (
+      candidates: typeof beforeCandidates,
+      limit: number,
+    ) => {
+      const out: NonNullable<
+        Awaited<ReturnType<typeof this.buildScheduleResult>>
+      >[] = [];
       for (const schedule of candidates) {
         if (out.length >= limit) break;
-        const r = await this.buildScheduleResult(schedule as any, originStationId, destinationStationId, totalPassengers, nationality);
+        const r = await this.buildScheduleResult(
+          schedule as any,
+          originStationId,
+          destinationStationId,
+          totalPassengers,
+          nationality,
+        );
         if (r?.hasAvailability) out.push(r);
       }
       return out;
@@ -208,21 +293,28 @@ export class SearchService {
     childCount?: number,
     nationality?: string,
   ) {
-    const [y, m, d] = dateStr.split('-').map(Number);
-    const date    = new Date(y, m - 1, d, 0, 0, 0, 0);
-    const nextDay = new Date(y, m - 1, d + 1, 0, 0, 0, 0);
+    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`,
+    );
     const now = new Date();
     const totalPassengers = adultCount + (childCount ?? 0);
 
     // Use now as the lower bound for today so we don't fetch schedules that have
     // already fully departed. The per-segment cutoff check in buildScheduleResult
     // handles the exact check using each stop's own plannedDepartureAt.
-    const isToday = now.getFullYear() === y && now.getMonth() === m - 1 && now.getDate() === d;
+    const isToday =
+      now.getFullYear() === y &&
+      now.getMonth() === m - 1 &&
+      now.getDate() === d;
     const earliest = isToday ? now : date;
 
     const schedules = await this.prisma.trainSchedule.findMany({
       where: {
-        status: 'SCHEDULED',
+        status: "SCHEDULED",
         isPackageOnly: false,
         departureAt: { gte: earliest, lt: nextDay },
         stopTimes: { some: { stationId: originStationId } },
@@ -232,11 +324,19 @@ export class SearchService {
     });
 
     const results = await Promise.all(
-      schedules.map(schedule =>
-        this.buildScheduleResult(schedule as any, originStationId, destinationStationId, totalPassengers, nationality)
-      )
+      schedules.map((schedule) =>
+        this.buildScheduleResult(
+          schedule as any,
+          originStationId,
+          destinationStationId,
+          totalPassengers,
+          nationality,
+        ),
+      ),
+    );
+    return results.filter(
+      (r): r is NonNullable<typeof r> => !!r && r.hasAvailability,
     );
-    return results.filter((r): r is NonNullable<typeof r> => !!r && r.hasAvailability);
   }
 
   // ── Transit search ─────────────────────────────────────────────────────────
@@ -251,10 +351,16 @@ export class SearchService {
     childCount?: number,
     nationality?: string,
   ) {
-    const [y, m, d] = dateStr.split('-').map(Number);
-    const dayStart = new Date(y, m - 1, d, 0, 0, 0, 0);
-    const dayEnd   = new Date(y, m - 1, d + 1, 0, 0, 0, 0);
-    const leg2WindowEnd = new Date(dayEnd.getTime() + this.MAX_CONNECTION_MINUTES * 60_000);
+    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`,
+    );
+    const leg2WindowEnd = new Date(
+      dayEnd.getTime() + this.MAX_CONNECTION_MINUTES * 60_000,
+    );
     const totalPassengers = adultCount + (childCount ?? 0);
 
     // Load leg1 and all potential leg2 candidates in one parallel round-trip
@@ -262,7 +368,7 @@ export class SearchService {
     const [leg1Schedules, allCandidates] = await Promise.all([
       this.prisma.trainSchedule.findMany({
         where: {
-          status: 'SCHEDULED',
+          status: "SCHEDULED",
           isPackageOnly: false,
           departureAt: { gte: dayStart, lt: dayEnd },
           stopTimes: { some: { stationId: originStationId } },
@@ -272,7 +378,7 @@ export class SearchService {
       }),
       this.prisma.trainSchedule.findMany({
         where: {
-          status: 'SCHEDULED',
+          status: "SCHEDULED",
           isPackageOnly: false,
           departureAt: { gte: dayStart, lt: leg2WindowEnd },
           coachAssignments: { some: {} },
@@ -284,61 +390,125 @@ export class SearchService {
     const results: any[] = [];
 
     for (const leg1 of leg1Schedules as ScheduleWithIncludes[]) {
-      const originStop = leg1.stopTimes.find(s => s.stationId === originStationId);
+      const originStop = leg1.stopTimes.find(
+        (s) => s.stationId === originStationId,
+      );
       if (!originStop) continue;
 
       const candidateTransitStops = leg1.stopTimes.filter(
-        s => s.sequence > originStop.sequence,
+        (s) => s.sequence > originStop.sequence,
       );
 
       for (const transitStop of candidateTransitStops) {
-        const leg1HasDest = leg1.stopTimes.some(s => s.stationId === destinationStationId);
+        const leg1HasDest = leg1.stopTimes.some(
+          (s) => s.stationId === destinationStationId,
+        );
         if (leg1HasDest) continue;
 
         const transitStationId = transitStop.stationId;
-        const leg1ArrivalAt = transitStop.plannedArrivalAt ?? transitStop.plannedDepartureAt ?? leg1.arrivalAt;
+        const leg1ArrivalAt =
+          transitStop.plannedArrivalAt ??
+          transitStop.plannedDepartureAt ??
+          leg1.arrivalAt;
 
-        const connWindowStart = new Date(new Date(leg1ArrivalAt).getTime() + this.MIN_CONNECTION_MINUTES * 60_000);
-        const connWindowEnd   = new Date(new Date(leg1ArrivalAt).getTime() + this.MAX_CONNECTION_MINUTES * 60_000);
+        const connWindowStart = new Date(
+          new Date(leg1ArrivalAt).getTime() +
+            this.MIN_CONNECTION_MINUTES * 60_000,
+        );
+        const connWindowEnd = new Date(
+          new Date(leg1ArrivalAt).getTime() +
+            this.MAX_CONNECTION_MINUTES * 60_000,
+        );
 
         // Filter from pre-loaded candidates in memory — no extra DB query
-        const leg2Schedules = (allCandidates as ScheduleWithIncludes[]).filter(s => {
-          const dep = new Date(s.departureAt).getTime();
-          return dep >= connWindowStart.getTime()
-            && dep <= connWindowEnd.getTime()
-            && s.stopTimes.some(st => st.stationId === transitStationId);
-        });
+        const leg2Schedules = (allCandidates as ScheduleWithIncludes[]).filter(
+          (s) => {
+            const dep = new Date(s.departureAt).getTime();
+            return (
+              dep >= connWindowStart.getTime() &&
+              dep <= connWindowEnd.getTime() &&
+              s.stopTimes.some((st) => st.stationId === transitStationId)
+            );
+          },
+        );
 
         for (const leg2 of leg2Schedules) {
-          const leg2TransitStop = leg2.stopTimes.find(s => s.stationId === transitStationId);
-          const leg2DestStop    = leg2.stopTimes.find(s => s.stationId === destinationStationId);
+          const leg2TransitStop = leg2.stopTimes.find(
+            (s) => s.stationId === transitStationId,
+          );
+          const leg2DestStop = leg2.stopTimes.find(
+            (s) => s.stationId === destinationStationId,
+          );
 
           if (!leg2TransitStop || !leg2DestStop) continue;
           if (leg2TransitStop.sequence >= leg2DestStop.sequence) continue;
 
           const [leg1Result, leg2Result] = await Promise.all([
-            this.buildScheduleResult(leg1, originStationId, transitStationId, totalPassengers, nationality),
-            this.buildScheduleResult(leg2, transitStationId, destinationStationId, totalPassengers, nationality),
+            this.buildScheduleResult(
+              leg1,
+              originStationId,
+              transitStationId,
+              totalPassengers,
+              nationality,
+            ),
+            this.buildScheduleResult(
+              leg2,
+              transitStationId,
+              destinationStationId,
+              totalPassengers,
+              nationality,
+            ),
           ]);
 
           if (!leg1Result || !leg2Result) continue;
-          if (!leg1Result.hasAvailability || !leg2Result.hasAvailability) continue;
+          if (!leg1Result.hasAvailability || !leg2Result.hasAvailability)
+            continue;
 
-          const leg2DepartureAt = leg2TransitStop.plannedDepartureAt ?? leg2.departureAt;
+          const leg2DepartureAt =
+            leg2TransitStop.plannedDepartureAt ?? leg2.departureAt;
           const connectionMinutes = Math.round(
-            (new Date(leg2DepartureAt).getTime() - new Date(leg1ArrivalAt).getTime()) / 60_000,
+            (new Date(leg2DepartureAt).getTime() -
+              new Date(leg1ArrivalAt).getTime()) /
+              60_000,
           );
 
-          const leg1MinFare        = Math.min(...(leg1Result.faresByClass as any[]).map((f: any) => f.baseFareMinor).filter((n: number) => n > 0), Infinity);
-          const leg2MinFare        = Math.min(...(leg2Result.faresByClass as any[]).map((f: any) => f.baseFareMinor).filter((n: number) => n > 0), Infinity);
-          const leg1MinDisplay     = Math.min(...(leg1Result.faresByClass as any[]).map((f: any) => f.displayAmountMinor).filter((n: number) => n > 0), Infinity);
-          const leg2MinDisplay     = Math.min(...(leg2Result.faresByClass as any[]).map((f: any) => f.displayAmountMinor).filter((n: number) => n > 0), Infinity);
-          const combinedMinFareMinor   = (isFinite(leg1MinFare)    ? leg1MinFare    : 0) + (isFinite(leg2MinFare)    ? leg2MinFare    : 0);
-          const combinedMinFareDisplay = (isFinite(leg1MinDisplay) ? leg1MinDisplay : 0) + (isFinite(leg2MinDisplay) ? leg2MinDisplay : 0);
-          const displayCurrency = leg1Result.displayCurrency ?? leg2Result.displayCurrency ?? Currency.ETB;
+          const leg1MinFare = Math.min(
+            ...(leg1Result.faresByClass as any[])
+              .map((f: any) => f.baseFareMinor)
+              .filter((n: number) => n > 0),
+            Infinity,
+          );
+          const leg2MinFare = Math.min(
+            ...(leg2Result.faresByClass as any[])
+              .map((f: any) => f.baseFareMinor)
+              .filter((n: number) => n > 0),
+            Infinity,
+          );
+          const leg1MinDisplay = Math.min(
+            ...(leg1Result.faresByClass as any[])
+              .map((f: any) => f.displayAmountMinor)
+              .filter((n: number) => n > 0),
+            Infinity,
+          );
+          const leg2MinDisplay = Math.min(
+            ...(leg2Result.faresByClass as any[])
+              .map((f: any) => f.displayAmountMinor)
+              .filter((n: number) => n > 0),
+            Infinity,
+          );
+          const combinedMinFareMinor =
+            (isFinite(leg1MinFare) ? leg1MinFare : 0) +
+            (isFinite(leg2MinFare) ? leg2MinFare : 0);
+          const combinedMinFareDisplay =
+            (isFinite(leg1MinDisplay) ? leg1MinDisplay : 0) +
+            (isFinite(leg2MinDisplay) ? leg2MinDisplay : 0);
+          const displayCurrency =
+            leg1Result.displayCurrency ??
+            leg2Result.displayCurrency ??
+            Currency.ETB;
 
           results.push({
-            type: 'TRANSIT',
+            type: "TRANSIT",
             transitStationId,
             transitStationName: transitStop.station.name,
             connectionMinutes,
@@ -348,9 +518,11 @@ export class SearchService {
             combinedMinFareMinor,
             combinedMinFareDisplay,
             departureAt: leg1Result.departureAt,
-            arrivalAt:   leg2Result.arrivalAt,
+            arrivalAt: leg2Result.arrivalAt,
             totalDurationMinutes:
-              leg1Result.durationMinutes + connectionMinutes + leg2Result.durationMinutes,
+              leg1Result.durationMinutes +
+              connectionMinutes +
+              leg2Result.durationMinutes,
           });
         }
       }
@@ -366,32 +538,47 @@ export class SearchService {
     totalPassengers: number,
     nationality?: string,
   ) {
-    const originStop = schedule.stopTimes.find(s => s.stationId === originStationId);
-    const destStop   = schedule.stopTimes.find(s => s.stationId === destinationStationId);
-    if (!originStop || !destStop || originStop.sequence >= destStop.sequence) return null;
+    const originStop = schedule.stopTimes.find(
+      (s) => s.stationId === originStationId,
+    );
+    const destStop = schedule.stopTimes.find(
+      (s) => s.stationId === destinationStationId,
+    );
+    if (!originStop || !destStop || originStop.sequence >= destStop.sequence)
+      return null;
 
     // Segment-level cutoff: use the origin stop's planned departure, not the
     // schedule's overall departureAt (which is station A's time). This lets
     // B→D remain bookable even after A→D closes.
     // Cutoff resolution: stop-level override → route default → 30 min fallback.
     const now = new Date();
-    const segmentDepartureAt = originStop.plannedDepartureAt ?? schedule.departureAt;
-    const routeStop = schedule.route?.stops?.find(s => s.stationId === originStationId);
-    const checkinMinutes = routeStop?.checkinMinutesBefore ?? schedule.route?.checkinMinutesBefore ?? 30;
-    if (segmentDepartureAt.getTime() - now.getTime() <= checkinMinutes * 60 * 1000) return null;
+    const segmentDepartureAt =
+      originStop.plannedDepartureAt ?? schedule.departureAt;
+    const routeStop = schedule.route?.stops?.find(
+      (s) => s.stationId === originStationId,
+    );
+    const checkinMinutes =
+      routeStop?.checkinMinutesBefore ??
+      schedule.route?.checkinMinutesBefore ??
+      30;
+    if (
+      segmentDepartureAt.getTime() - now.getTime() <=
+      checkinMinutes * 60 * 1000
+    )
+      return null;
 
     // Collect all valid seat IDs upfront for a single batch availability check
-    const allValidSeatIds = schedule.coachAssignments.flatMap(a =>
+    const allValidSeatIds = schedule.coachAssignments.flatMap((a) =>
       a.coach.seats
-        .filter((s: any) => s.status !== 'BLOCKED' && s.seatNumber?.trim())
-        .map((s: any) => s.id as string)
+        .filter((s: any) => s.status !== "BLOCKED" && s.seatNumber?.trim())
+        .map((s: any) => s.id as string),
     );
 
     // Exclude schedules with no seats at all
     if (allValidSeatIds.length === 0) return null;
 
-    // Run availability batch and fare calculation in parallel
-    const [freeSeats, faresByClass] = await Promise.all([
+    // Run availability batch, fare calculation, and schedule-scoped seat blocks in parallel
+    const [freeSeatsRaw, faresByClass, scheduleBlocks] = await Promise.all([
       this.segmentsService.getFreeSeatIds(
         schedule.id,
         allValidSeatIds,
@@ -399,8 +586,27 @@ export class SearchService {
         originStop.sequence,
         destStop.sequence,
       ),
-      this.calculateFaresForSegment(schedule, originStationId, destinationStationId, nationality),
+      this.calculateFaresForSegment(
+        schedule,
+        originStationId,
+        destinationStationId,
+        nationality,
+      ),
+      this.prisma.seatBlock.findMany({
+        where: {
+          scheduleId: schedule.id,
+          seatId: { in: allValidSeatIds },
+        },
+        select: { seatId: true },
+      }),
     ]);
+    const scheduleBlockedIds = new Set(
+      scheduleBlocks.map((b: any) => b.seatId),
+    );
+    // Seats that are free from holds/bookings AND not schedule-blocked
+    const freeSeats = new Set(
+      [...freeSeatsRaw].filter((id) => !scheduleBlockedIds.has(id)),
+    );
 
     // Compute per-class availability using the pre-computed free seat set. A coach type
     // has separate seat classes per nationality tier (e.g. "VIP Bed Upper (Local)" AND
@@ -411,62 +617,116 @@ export class SearchService {
     // are actually free. Matched via the class's own bedPosition field (case-insensitive:
     // Seat.bedPosition is lowercase, SeatClass.bedPosition is uppercase) rather than a
     // name substring, since that's an exact, unambiguous signal.
-    const nationalityUpper = (nationality ?? '').toUpperCase();
-    const resolvedNationalityType = (nationalityUpper === 'ETHIOPIAN' || nationalityUpper === 'DJIBOUTIAN')
-      ? 'LOCAL' : 'INTERNATIONAL';
+    const nationalityUpper = (nationality ?? "").toUpperCase();
+    const resolvedNationalityType =
+      nationalityUpper === "ETHIOPIAN" || nationalityUpper === "DJIBOUTIAN"
+        ? "LOCAL"
+        : "INTERNATIONAL";
 
     const availabilityByClass: Record<string, number> = {};
     for (const assignment of schedule.coachAssignments) {
-      const seatClasses = (assignment.coach.coachType?.seatClasses ?? []).filter(
-        (sc: any) => !sc.nationalityType || sc.nationalityType === resolvedNationalityType,
+      const seatClasses = (
+        assignment.coach.coachType?.seatClasses ?? []
+      ).filter(
+        (sc: any) =>
+          !sc.nationalityType || sc.nationalityType === resolvedNationalityType,
       );
       const isBedCoach = assignment.coach.seats.some((s: any) => s.bedPosition);
 
       if (isBedCoach) {
-        for (const bedPosition of ['upper', 'middle', 'lower']) {
+        for (const bedPosition of ["upper", "middle", "lower"]) {
           let count = 0;
           for (const seat of assignment.coach.seats) {
-            if (seat.bedPosition !== bedPosition || seat.status === 'BLOCKED' || !seat.seatNumber?.trim()) continue;
+            if (
+              seat.bedPosition !== bedPosition ||
+              seat.status === "BLOCKED" ||
+              !seat.seatNumber?.trim()
+            )
+              continue;
             if (freeSeats.has(seat.id)) count++;
           }
           if (count > 0) {
-            const matchingClass = seatClasses.find((sc: any) => sc.bedPosition?.toLowerCase() === bedPosition);
-            if (matchingClass) availabilityByClass[matchingClass.name] = (availabilityByClass[matchingClass.name] ?? 0) + count;
+            const matchingClass = seatClasses.find(
+              (sc: any) => sc.bedPosition?.toLowerCase() === bedPosition,
+            );
+            if (matchingClass)
+              availabilityByClass[matchingClass.name] =
+                (availabilityByClass[matchingClass.name] ?? 0) + count;
           }
         }
       } else {
         let available = 0;
         for (const seat of assignment.coach.seats) {
-          if (seat.status === 'BLOCKED' || !seat.seatNumber?.trim()) continue;
+          if (seat.status === "BLOCKED" || !seat.seatNumber?.trim()) continue;
           if (freeSeats.has(seat.id)) available++;
         }
-        const names = seatClasses.length > 0 ? seatClasses.map((sc: any) => sc.name) : ['Standard'];
-        for (const name of names) availabilityByClass[name] = (availabilityByClass[name] ?? 0) + available;
+        const names =
+          seatClasses.length > 0
+            ? seatClasses.map((sc: any) => sc.name)
+            : ["Standard"];
+        for (const name of names)
+          availabilityByClass[name] =
+            (availabilityByClass[name] ?? 0) + available;
       }
     }
 
-    const coachTypes   = this.buildCoachTypeDetails(schedule, faresByClass, nationality, availabilityByClass);
-    const legDepartureAt = originStop.plannedDepartureAt ?? schedule.departureAt;
-    const legArrivalAt   = destStop.plannedArrivalAt   ?? schedule.arrivalAt;
+    const coachTypes = this.buildCoachTypeDetails(
+      schedule,
+      faresByClass,
+      nationality,
+      availabilityByClass,
+    );
+    const legDepartureAt = schedule.departureAt;
+    const legArrivalAt = schedule.arrivalAt;
 
-    const displayCurrency = faresByClass[0]?.displayCurrency ?? resolveCurrencyFromNationality(nationality);
+    const displayCurrency =
+      faresByClass[0]?.displayCurrency ??
+      resolveCurrencyFromNationality(nationality);
 
     return {
-      type: 'DIRECT',
+      type: "DIRECT",
       scheduleId: schedule.id,
       trainNumber: schedule.train.number,
-      trainName:   schedule.train.name,
-      origin: { id: originStop.stationId, code: originStop.station.code, name: originStop.station.name, city: originStop.station.city, sequence: originStop.sequence },
-      destination: { id: destStop.stationId, code: destStop.station.code, name: destStop.station.name, city: destStop.station.city, sequence: destStop.sequence },
+      trainName: schedule.train.name,
+      origin: {
+        id: originStop.stationId,
+        code: originStop.station.code,
+        name: originStop.station.name,
+        city: originStop.station.city,
+        sequence: originStop.sequence,
+      },
+      destination: {
+        id: destStop.stationId,
+        code: destStop.station.code,
+        name: destStop.station.name,
+        city: destStop.station.city,
+        sequence: destStop.sequence,
+      },
       departureAt: legDepartureAt,
-      arrivalAt:   legArrivalAt,
-      durationMinutes: Math.round((new Date(legArrivalAt).getTime() - new Date(legDepartureAt).getTime()) / 60_000),
+      arrivalAt: legArrivalAt,
+      durationMinutes: Math.round(
+        (new Date(legArrivalAt).getTime() -
+          new Date(legDepartureAt).getTime()) /
+          60_000,
+      ),
       status: schedule.status,
       stops: schedule.stopTimes
-        .filter(st => st.sequence >= originStop.sequence && st.sequence <= destStop.sequence)
-        .map(st => ({ stationId: st.stationId, stationName: st.station.name, sequence: st.sequence, plannedArrivalAt: st.plannedArrivalAt, plannedDepartureAt: st.plannedDepartureAt })),
+        .filter(
+          (st) =>
+            st.sequence >= originStop.sequence &&
+            st.sequence <= destStop.sequence,
+        )
+        .map((st) => ({
+          stationId: st.stationId,
+          stationName: st.station.name,
+          sequence: st.sequence,
+          plannedArrivalAt: st.plannedArrivalAt,
+          plannedDepartureAt: st.plannedDepartureAt,
+        })),
       availabilityByClass,
-      hasAvailability: Object.values(availabilityByClass).some(n => n >= totalPassengers),
+      hasAvailability: Object.values(availabilityByClass).some(
+        (n) => n >= totalPassengers,
+      ),
       displayCurrency,
       faresByClass,
       coachTypes,
@@ -479,20 +739,34 @@ export class SearchService {
       include: {
         originStation: true,
         destinationStation: true,
-        stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } },
+        stopTimes: { include: { station: true }, orderBy: { sequence: "asc" } },
       },
     });
-    if (!schedule) throw new NotFoundException('Schedule not found');
-    if (!schedule.routeId) throw new NotFoundException('Schedule has no route configured for fare calculation');
+    if (!schedule) throw new NotFoundException("Schedule not found");
+    if (!schedule.routeId)
+      throw new NotFoundException(
+        "Schedule has no route configured for fare calculation",
+      );
 
-    const originStop = schedule.stopTimes.find((s: any) => s.stationId === dto.originStationId);
-    const destStop = schedule.stopTimes.find((s: any) => s.stationId === dto.destinationStationId);
+    const originStop = schedule.stopTimes.find(
+      (s: any) => s.stationId === dto.originStationId,
+    );
+    const destStop = schedule.stopTimes.find(
+      (s: any) => s.stationId === dto.destinationStationId,
+    );
     if (!originStop || !destStop || originStop.sequence >= destStop.sequence) {
-      throw new NotFoundException('Origin or destination not found on this schedule');
+      throw new NotFoundException(
+        "Origin or destination not found on this schedule",
+      );
     }
 
-    const seatClass = await this.prisma.seatClass.findFirst({ where: { name: dto.seatClassName } });
-    if (!seatClass) throw new NotFoundException(`Seat class '${dto.seatClassName}' not found`);
+    const seatClass = await this.prisma.seatClass.findFirst({
+      where: { name: dto.seatClassName },
+    });
+    if (!seatClass)
+      throw new NotFoundException(
+        `Seat class '${dto.seatClassName}' not found`,
+      );
 
     const fare = await this.fareEngine.calculate({
       routeId: schedule.routeId,
@@ -510,10 +784,16 @@ export class SearchService {
     const totalMinor = Math.max(0, fare.totalMinor - loyaltyMinor);
 
     const segmentRoute = `${originStop.station.code}-${destStop.station.code}`;
-    const displayCurrency = dto.displayCurrency ?? resolveCurrencyFromNationality(dto.nationality);
-    const displayTotalMinor = displayCurrency !== Currency.ETB
-      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
-      : totalMinor;
+    const displayCurrency =
+      dto.displayCurrency ?? resolveCurrencyFromNationality(dto.nationality);
+    const displayTotalMinor =
+      displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(
+            totalMinor,
+            Currency.ETB,
+            displayCurrency,
+          )
+        : totalMinor;
 
     return {
       scheduleId: dto.scheduleId,
@@ -535,8 +815,8 @@ export class SearchService {
       discountMinor: fare.discountMinor,
       taxesFeesMinor: 0,
       loyaltyRedemptionMinor: loyaltyMinor,
-      totalMinor,
-      currency: 'ETB',
+      totalMinor: displayTotalMinor,
+      currency: displayCurrency,
       displayCurrency,
       displayTotalMinor,
     };
@@ -545,10 +825,17 @@ export class SearchService {
   async getFareBreakdown(dto: FareBreakdownRequestDto) {
     const schedule = await this.prisma.trainSchedule.findUnique({
       where: { id: dto.scheduleId },
-      select: { routeId: true, originStationId: true, destinationStationId: true },
+      select: {
+        routeId: true,
+        originStationId: true,
+        destinationStationId: true,
+      },
     });
-    if (!schedule) throw new NotFoundException('Schedule not found');
-    if (!schedule.routeId) throw new NotFoundException('Schedule has no route configured for fare calculation');
+    if (!schedule) throw new NotFoundException("Schedule not found");
+    if (!schedule.routeId)
+      throw new NotFoundException(
+        "Schedule has no route configured for fare calculation",
+      );
 
     const now = new Date();
     const displayCurrency = dto.displayCurrency ?? Currency.ETB;
@@ -557,18 +844,22 @@ export class SearchService {
     try {
       parsedPassengers = JSON.parse(dto.passengers as unknown as string);
     } catch {
-      throw new NotFoundException('passengers must be a valid JSON array');
+      throw new NotFoundException("passengers must be a valid JSON array");
     }
 
     // Categorise passengers by age
-    const categorised = parsedPassengers.map(p => {
+    const categorised = parsedPassengers.map((p) => {
       const ageMs = now.getTime() - new Date(p.dateOfBirth).getTime();
       const ageYears = ageMs / (1000 * 60 * 60 * 24 * 365.25);
-      return { ...p, category: (ageYears >= 5 ? 'ADULT' : 'CHILD') as 'ADULT' | 'CHILD', ageYears };
+      return {
+        ...p,
+        category: (ageYears >= 5 ? "ADULT" : "CHILD") as "ADULT" | "CHILD",
+        ageYears,
+      };
     });
 
-    const adultCount = categorised.filter(p => p.category === 'ADULT').length;
-    const childCount = categorised.filter(p => p.category === 'CHILD').length;
+    const adultCount = categorised.filter((p) => p.category === "ADULT").length;
+    const childCount = categorised.filter((p) => p.category === "CHILD").length;
 
     // Ask the fare engine for the authoritative free-child count using the full group
     // Use the first passenger's seatClassId as a representative — freeChildrenCount
@@ -585,10 +876,20 @@ export class SearchService {
     });
     const freeChildrenAllowed = groupFare.freeChildrenCount;
 
-    // Calculate per-passenger fare rate (engine called with 1 adult, 0 children — pure rate lookup)
+    // Pre-compute isFree per passenger index synchronously so the race-free
+    // counter assignment isn't corrupted by concurrent Promise.all resolution.
     let freeChildrenUsed = 0;
+    const isFreeByIndex = categorised.map((p) => {
+      if (p.category === "CHILD" && freeChildrenUsed < freeChildrenAllowed) {
+        freeChildrenUsed++;
+        return true;
+      }
+      return false;
+    });
+
+    // Calculate per-passenger fare rate (engine called with 1 adult, 0 children — pure rate lookup)
     const passengerLines = await Promise.all(
-      categorised.map(async (p) => {
+      categorised.map(async (p, idx) => {
         const fare = await this.fareEngine.calculate({
           routeId: schedule.routeId!,
           originStationId: dto.originStationId,
@@ -600,15 +901,19 @@ export class SearchService {
           childCount: 0,
         });
 
-        const isFree = p.category === 'CHILD' && freeChildrenUsed < freeChildrenAllowed;
-        if (isFree) freeChildrenUsed++;
+        const isFree = isFreeByIndex[idx];
 
         const fareMinor = isFree
           ? fare.premiumPerPassenger + fare.insurancePerPassenger
           : fare.farePerPassengerMinor;
-        const displayFareMinor = displayCurrency !== Currency.ETB
-          ? await this.currencyService.convertAmount(fareMinor, Currency.ETB, displayCurrency)
-          : fareMinor;
+        const displayFareMinor =
+          displayCurrency !== Currency.ETB
+            ? await this.currencyService.convertAmount(
+                fareMinor,
+                Currency.ETB,
+                displayCurrency,
+              )
+            : fareMinor;
 
         return {
           passengerName: p.passengerName,
@@ -633,18 +938,25 @@ export class SearchService {
 
     let discountMinor = 0;
     if (dto.promoCode) {
-      const promo = await this.prisma.promotion.findUnique({ where: { code: dto.promoCode } });
+      const promo = await this.prisma.promotion.findUnique({
+        where: { code: dto.promoCode },
+      });
       if (promo?.active && promo.validUntil > now) {
         discountMinor = promo.percentOff
-          ? Math.round(subtotalMinor * promo.percentOff / 100)
+          ? Math.round((subtotalMinor * promo.percentOff) / 100)
           : (promo.amountOffMinor ?? 0);
       }
     }
 
     const totalMinor = subtotalMinor - discountMinor;
-    const displayTotalMinor = displayCurrency !== Currency.ETB
-      ? await this.currencyService.convertAmount(totalMinor, Currency.ETB, displayCurrency)
-      : totalMinor;
+    const displayTotalMinor =
+      displayCurrency !== Currency.ETB
+        ? await this.currencyService.convertAmount(
+            totalMinor,
+            Currency.ETB,
+            displayCurrency,
+          )
+        : totalMinor;
 
     return {
       scheduleId: dto.scheduleId,
@@ -653,8 +965,8 @@ export class SearchService {
       passengers: passengerLines,
       subtotalMinor,
       discountMinor,
-      totalMinor,
-      currency: 'ETB',
+      totalMinor: displayTotalMinor,
+      currency: displayCurrency,
       displayCurrency,
       displayTotalMinor,
     };
@@ -665,18 +977,27 @@ export class SearchService {
     originStationId: string,
     destinationStationId: string,
     nationality?: string,
-  ): Promise<Array<{ seatClassName: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number }>> {
+  ): Promise<
+    Array<{
+      seatClassName: string;
+      baseFareMinor: number;
+      displayCurrency: Currency;
+      displayAmountMinor: number;
+    }>
+  > {
     const displayCurrency = resolveCurrencyFromNationality(nationality);
 
-    const nationalityUpper = (nationality ?? '').toUpperCase();
-    const nationalityType = (nationalityUpper === 'ETHIOPIAN' || nationalityUpper === 'DJIBOUTIAN')
-      ? 'LOCAL' : 'INTERNATIONAL';
+    const nationalityUpper = (nationality ?? "").toUpperCase();
+    const nationalityType =
+      nationalityUpper === "ETHIOPIAN" || nationalityUpper === "DJIBOUTIAN"
+        ? "LOCAL"
+        : "INTERNATIONAL";
 
     // Collect seat class IDs from the schedule include for the ID set,
     // but fetch fresh records from DB so updated baseFareMinor is always current
     const seatClassIdSet = new Set<string>();
     for (const a of schedule.coachAssignments) {
-      for (const sc of (a.coach.coachType?.seatClasses ?? [])) {
+      for (const sc of a.coach.coachType?.seatClasses ?? []) {
         if (sc.isActive) seatClassIdSet.add(sc.id);
       }
     }
@@ -684,14 +1005,13 @@ export class SearchService {
       where: {
         id: { in: Array.from(seatClassIdSet) },
         isActive: true,
-        OR: [
-          { nationalityType: null },
-          { nationalityType: nationalityType },
-        ],
+        OR: [{ nationalityType: null }, { nationalityType: nationalityType }],
       },
     });
-    const seatClassMap = new Map(freshSeatClasses.map(sc => [sc.id, sc]));
-    const seatClasses = freshSeatClasses.sort((a, b) => a.baseFareMinor - b.baseFareMinor);
+    const seatClassMap = new Map(freshSeatClasses.map((sc) => [sc.id, sc]));
+    const seatClasses = freshSeatClasses.sort(
+      (a, b) => a.baseFareMinor - b.baseFareMinor,
+    );
 
     if (seatClasses.length === 0) return [];
 
@@ -713,9 +1033,9 @@ export class SearchService {
               // engine may resolve a nationality-specific variant (nationalitySeatClass)
               // whose name differs from sc.name, which would cause the class to be
               // silently dropped from coachTypes and show N/A on the results page.
-              seatClassName:      sc.name,
-              baseFareMinor:      fare.totalMinor,
-              displayCurrency:    fare.billingCurrency as Currency,
+              seatClassName: sc.name,
+              baseFareMinor: fare.totalMinor,
+              displayCurrency: fare.billingCurrency as Currency,
               displayAmountMinor: fare.totalInBillingCurrency,
             };
           } catch {
@@ -725,16 +1045,27 @@ export class SearchService {
       );
 
       const validResults = results.filter(
-        (r): r is { seatClassName: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number } => r !== null,
+        (
+          r,
+        ): r is {
+          seatClassName: string;
+          baseFareMinor: number;
+          displayCurrency: Currency;
+          displayAmountMinor: number;
+        } => r !== null,
       );
       if (validResults.length > 0) return validResults;
     }
 
     // Fallback: use station codes from already-loaded stopTimes when available
-    const originStop = schedule.stopTimes.find(st => st.stationId === originStationId);
-    const destStop   = schedule.stopTimes.find(st => st.stationId === destinationStationId);
+    const originStop = schedule.stopTimes.find(
+      (st) => st.stationId === originStationId,
+    );
+    const destStop = schedule.stopTimes.find(
+      (st) => st.stationId === destinationStationId,
+    );
     const originCode = originStop?.station?.code;
-    const destCode   = destStop?.station?.code;
+    const destCode = destStop?.station?.code;
 
     if (originCode && destCode) {
       const segmentRoute = `${originCode}-${destCode}`;
@@ -750,13 +1081,18 @@ export class SearchService {
       });
 
       if (fareRules.length > 0) {
-        const exchangeRate = await this.currencyService.getExchangeRate(Currency.ETB, displayCurrency);
+        const exchangeRate = await this.currencyService.getExchangeRate(
+          Currency.ETB,
+          displayCurrency,
+        );
         const TAX_RATE = 0.05;
-        return fareRules.map(rule => {
-          const totalMinor = rule.baseFareMinor + Math.round(rule.baseFareMinor * TAX_RATE);
+        return fareRules.map((rule) => {
+          const totalMinor =
+            rule.baseFareMinor + Math.round(rule.baseFareMinor * TAX_RATE);
           return {
-            seatClassName:      seatClassMap.get(rule.seatClassId)?.name ?? 'Unknown',
-            baseFareMinor:      totalMinor,
+            seatClassName:
+              seatClassMap.get(rule.seatClassId)?.name ?? "Unknown",
+            baseFareMinor: totalMinor,
             displayCurrency,
             displayAmountMinor: Math.round(totalMinor * exchangeRate),
           };
@@ -770,7 +1106,12 @@ export class SearchService {
   // buildCoachTypeDetails is pure in-memory — no async needed
   private buildCoachTypeDetails(
     schedule: ScheduleWithIncludes,
-    faresByClass: Array<{ seatClassName: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number }>,
+    faresByClass: Array<{
+      seatClassName: string;
+      baseFareMinor: number;
+      displayCurrency: Currency;
+      displayAmountMinor: number;
+    }>,
     nationality?: string,
     availabilityByClass: Record<string, number> = {},
   ): Array<{
@@ -778,7 +1119,13 @@ export class SearchService {
     coachTypeName: string;
     coachTypeCode: string;
     coachId: string;
-    classes: Array<{ name: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number; available: number }>;
+    classes: Array<{
+      name: string;
+      baseFareMinor: number;
+      displayCurrency: Currency;
+      displayAmountMinor: number;
+      available: number;
+    }>;
   }> {
     const coachTypeMap = new Map<
       string,
@@ -797,15 +1144,22 @@ export class SearchService {
         });
       }
 
-      const nationalityUpper = (nationality ?? '').toUpperCase();
-      const resolvedNationalityType = (nationalityUpper === 'ETHIOPIAN' || nationalityUpper === 'DJIBOUTIAN')
-        ? 'LOCAL' : 'INTERNATIONAL';
+      const nationalityUpper = (nationality ?? "").toUpperCase();
+      const resolvedNationalityType =
+        nationalityUpper === "ETHIOPIAN" || nationalityUpper === "DJIBOUTIAN"
+          ? "LOCAL"
+          : "INTERNATIONAL";
 
       const entry = coachTypeMap.get(coachType.id)!;
       coachType.seatClasses?.forEach((sc: any) => {
         // Exclude classes that belong to the wrong nationality type
-        if (sc.nationalityType && sc.nationalityType !== resolvedNationalityType) return;
-        if (faresByClass.some(f => f.seatClassName === sc.name)) entry.classNames.add(sc.name);
+        if (
+          sc.nationalityType &&
+          sc.nationalityType !== resolvedNationalityType
+        )
+          return;
+        if (faresByClass.some((f) => f.seatClassName === sc.name))
+          entry.classNames.add(sc.name);
       });
     }
 
@@ -813,17 +1167,29 @@ export class SearchService {
     for (const [, { coachType, classNames, coachId }] of coachTypeMap) {
       const classes = Array.from(classNames)
         .map((className) => {
-          const fareInfo = faresByClass.find((f) => f.seatClassName === className);
+          const fareInfo = faresByClass.find(
+            (f) => f.seatClassName === className,
+          );
           if (!fareInfo) return null;
           return {
-            name:               className,
-            baseFareMinor:      fareInfo.baseFareMinor,
-            displayCurrency:    fareInfo.displayCurrency,
+            name: className,
+            baseFareMinor: fareInfo.baseFareMinor,
+            displayCurrency: fareInfo.displayCurrency,
             displayAmountMinor: fareInfo.displayAmountMinor,
-            available:          availabilityByClass[className] ?? 0,
+            available: availabilityByClass[className] ?? 0,
           };
         })
-        .filter((c): c is { name: string; baseFareMinor: number; displayCurrency: Currency; displayAmountMinor: number; available: number } => c !== null)
+        .filter(
+          (
+            c,
+          ): c is {
+            name: string;
+            baseFareMinor: number;
+            displayCurrency: Currency;
+            displayAmountMinor: number;
+            available: number;
+          } => c !== null,
+        )
         .sort((a, b) => a.baseFareMinor - b.baseFareMinor);
 
       if (classes.length === 0) continue;
@@ -842,5 +1208,4 @@ export class SearchService {
       return minPriceA - minPriceB;
     });
   }
-
 }
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.controller.ts b/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
index 834973c71..c66dca06d 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.controller.ts
@@ -31,6 +31,16 @@ import { PASSENGER_PERMS } from "../../seed/passenger-permissions.registry";
 export class SeatsController {
   constructor(private service: SeatsService) {}
 
+  // ── Blocked Seats ─────────────────────────────────────────────────────────
+  @Get('blocks')
+  @PassengerStaff([PASSENGER_PERMS.seats.manage, PASSENGER_PERMS.admin])
+  @ApiBearerAuth('IAM-auth')
+  @ApiOperation({ summary: 'List all blocked seats with reason and coach info' })
+  @ApiResponse({ status: 200, description: 'Blocked seat records' })
+  getBlockedSeats() {
+    return this.service.getBlockedSeats();
+  }
+
   // ── Coach Availability ────────────────────────────────────────────────────
   @Get('coaches/:scheduleId')
   @SetMetadata('isPublic', true)
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.service.ts b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
index 963cc571d..abb747710 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
@@ -325,6 +325,18 @@ export class SeatsService {
         throw new ConflictException(`Seat(s) ${blocked.map(s => s.seatNumber).join(', ')} are already taken`);
 
       const seatLabelById = Object.fromEntries(seats.map(s => [s.id, s.seatNumber]));
+
+      // Schedule-scoped blocks prevent holding a seat on this specific schedule
+      // even if its global Seat.status is AVAILABLE.
+      const scheduleBlockRecords = await tx.seatBlock.findMany({
+        where: { scheduleId: dto.scheduleId, seatId: { in: seatIds } },
+        select: { seatId: true },
+      });
+      if (scheduleBlockRecords.length > 0) {
+        const blockedNums = scheduleBlockRecords.map(b => seatLabelById[b.seatId]).join(', ');
+        throw new ConflictException(`Seat(s) ${blockedNums} are blocked for this schedule`);
+      }
+
       const stopTimes = await tx.tripStopTime.findMany({
         where: { scheduleId: dto.scheduleId },
         select: { stationId: true, sequence: true },
@@ -615,6 +627,26 @@ export class SeatsService {
     await this.prisma.journey.deleteMany({ where: { bookingId } as any });
   }
 
+  async getBlockedSeats() {
+    const blocks = await this.prisma.seatBlock.findMany({
+      include: {
+        seat: { include: { coach: { select: { number: true } } } },
+      },
+      orderBy: { blockedAt: 'desc' },
+    });
+    return blocks.map(b => ({
+      id: b.id,
+      seatId: b.seatId,
+      seatNumber: b.seat.seatNumber,
+      coachNumber: b.seat.coach.number,
+      scheduleId: b.scheduleId,
+      reason: b.reason,
+      blockedBy: b.blockedBy,
+      blockedAt: b.blockedAt,
+      unblockAt: b.unblockAt,
+    }));
+  }
+
   async getCoachesWithAvailability(scheduleId: string, originStationId?: string, destinationStationId?: string) {
     const schedule = await this.prisma.trainSchedule.findUnique({
       where: { id: scheduleId },
@@ -691,11 +723,18 @@ export class SeatsService {
     const reqFrom = seqOf(schedule.originStationId) ?? 0;
     const reqTo = seqOf(schedule.destinationStationId) ?? stopTimes.length;
 
-    const unavailable = await this.segmentsService.getSeatAvailabilityMap(
-      scheduleId, allSeatIds, stopTimes, reqFrom, reqTo,
-    );
+    const [unavailable, scheduleBlocks] = await Promise.all([
+      this.segmentsService.getSeatAvailabilityMap(
+        scheduleId, allSeatIds, stopTimes, reqFrom, reqTo,
+      ),
+      this.prisma.seatBlock.findMany({
+        where: { scheduleId, seatId: { in: allSeatIds } },
+        select: { seatId: true },
+      }),
+    ]);
+    const scheduleBlockedIds = new Set(scheduleBlocks.map(b => b.seatId));
 
-    const availableSeats = seats.filter(s => !unavailable.has(s.id));
+    const availableSeats = seats.filter(s => !unavailable.has(s.id) && !scheduleBlockedIds.has(s.id));
 
     if (availableSeats.length < count) {
       throw new ConflictException(`Only ${availableSeats.length} seats available, requested ${count}`);
@@ -1020,7 +1059,7 @@ export class SeatsService {
         where: {
           OR: [
             { scheduleId: schedule.id },
-            { scheduleId: null, booking: { scheduleId: schedule.id } },
+            { booking: { scheduleId: schedule.id } },
           ],
           booking: { status: { in: ['CONFIRMED', 'BOARDED'] } },
         },
diff --git a/apps/edr-passenger-api/src/modules/tasks/tasks.service.ts b/apps/edr-passenger-api/src/modules/tasks/tasks.service.ts
index 2355485d4..4767c7eba 100644
--- a/apps/edr-passenger-api/src/modules/tasks/tasks.service.ts
+++ b/apps/edr-passenger-api/src/modules/tasks/tasks.service.ts
@@ -146,6 +146,7 @@ export class TasksService {
     await Promise.all([
       this.sendPaymentReminders(now),
       this.cancelExpiredPendingBookings(now),
+      this.cancelExpiredPendingPackageBookings(now),
     ]);
   }
 
@@ -333,6 +334,78 @@ export class TasksService {
     }
   }
 
+  // ── Cancel PackageBookings whose payment deadline has passed ──────────────
+  private async cancelExpiredPendingPackageBookings(now: Date) {
+    const twoHoursAgo    = new Date(now.getTime() - MAX_PAYMENT_HOURS * 60 * 60 * 1000);
+    const departureCutoff = new Date(now.getTime() + CUTOFF_MINUTES * 60 * 1000);
+
+    const expiredBookings = await this.prisma.packageBooking.findMany({
+      where: {
+        status: 'PENDING_PAYMENT',
+        OR: [
+          { createdAt: { lte: twoHoursAgo } },
+          { package: { outboundSchedule: { departureAt: { lte: departureCutoff } } } },
+        ],
+      },
+      include: {
+        package: {
+          include: {
+            outboundSchedule: {
+              include: { route: { select: { checkinMinutesBefore: true } } },
+            },
+          },
+        },
+      },
+    });
+
+    let cancelledCount = 0;
+
+    for (const booking of expiredBookings) {
+      try {
+        const createdAt     = booking.createdAt as Date;
+        const dep           = (booking.package as any).outboundSchedule.departureAt as Date;
+        const checkinMinutes = (booking.package as any).outboundSchedule.route?.checkinMinutesBefore ?? CUTOFF_MINUTES;
+        const paymentDeadline = computePaymentDeadline(createdAt, dep, checkinMinutes);
+        if (now < paymentDeadline) continue;
+
+        // Revert the tier's seat counters that were incremented when the booking was created.
+        const seatsReserved = booking.adultCount + Math.max(0, booking.childCount - booking.adultCount);
+        await this.prisma.packagePriceTier.update({
+          where: { id: booking.priceTierId },
+          data: {
+            bookedSeats:    { decrement: seatsReserved },
+            availableSeats: { increment: seatsReserved },
+          },
+        });
+
+        await this.prisma.packageBooking.update({
+          where: { id: booking.id },
+          data:  { status: 'CANCELLED' },
+        });
+
+        const message =
+          `EDR: Your package booking ${booking.bookingRef} ` +
+          `(departs ${fmtTime(dep)}) has been cancelled ` +
+          `because payment was not completed by ${fmtTime(paymentDeadline)}.`;
+
+        if (booking.contactPhone) {
+          await this.sms.sendSms({ to: booking.contactPhone, message }).catch(() => null);
+        }
+
+        this.logger.log(`Auto-cancelled package booking: ${booking.bookingRef} (deadline was ${fmtTime(paymentDeadline)})`);
+        cancelledCount++;
+      } catch (err) {
+        this.logger.error(
+          `Auto-cancel failed for package booking ${(booking as any).bookingRef}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+
+    if (cancelledCount > 0) {
+      this.logger.log(`Auto-cancelled ${cancelledCount} expired pending package booking(s)`);
+    }
+  }
+
   // ─────────────────────────────────────────────────────────────────────────
   // Daily at 02:00 EAT: purge expired/stale records to enforce data retention.
   // ─────────────────────────────────────────────────────────────────────────
diff --git a/apps/edr-passenger-web/backoffice/package.json b/apps/edr-passenger-web/backoffice/package.json
index 858fcd781..9d4327a42 100644
--- a/apps/edr-passenger-web/backoffice/package.json
+++ b/apps/edr-passenger-web/backoffice/package.json
@@ -19,6 +19,7 @@
     "lucide-react": "^0.446.0",
     "next": "^14.2.0",
     "react": "^18.3.1",
+    "react-day-picker": "^9.14.0",
     "react-dom": "^18.3.1",
     "recharts": "^2.12.0",
     "socket.io-client": "^4.8.3",
diff --git a/apps/edr-passenger-web/backoffice/src/app/dashboard/page.tsx b/apps/edr-passenger-web/backoffice/src/app/dashboard/page.tsx
index 2e5063fc0..b248fd68a 100644
--- a/apps/edr-passenger-web/backoffice/src/app/dashboard/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/dashboard/page.tsx
@@ -1,48 +1,77 @@
-'use client';
+"use client";
 
-import { useQuery } from '@tanstack/react-query';
-import { PermissionGuard } from '@/components/layout/PermissionGuard';
-import { PERMS } from '@/lib/permissions';
-import { Ticket, AlertCircle, BookOpen, Banknote, ArrowRight, ScanLine } from 'lucide-react';
-import { dashboardApi } from '@/lib/api/dashboard';
-import { apiClient } from '@/lib/api-client';
-import { formatCurrency } from '@/lib/utils';
-import { PieChart, Pie, Cell, Tooltip, ResponsiveContainer } from 'recharts';
-import Link from 'next/link';
+import { useQuery } from "@tanstack/react-query";
+import { PermissionGuard } from "@/components/layout/PermissionGuard";
+import { PERMS } from "@/lib/permissions";
+import {
+  Ticket,
+  AlertCircle,
+  BookOpen,
+  Banknote,
+  ArrowRight,
+  ScanLine,
+} from "lucide-react";
+import { dashboardApi } from "@/lib/api/dashboard";
+import { apiClient } from "@/lib/api-client";
+import { formatCurrency } from "@/lib/utils";
+import { PieChart, Pie, Cell, Tooltip, ResponsiveContainer } from "recharts";
+import Link from "next/link";
 
-const COLORS = ['#2563eb', '#10b981', '#f59e0b', '#ef4444', '#8b5cf6'];
+const COLORS = ["#2563eb", "#10b981", "#f59e0b", "#ef4444", "#8b5cf6"];
 
 function StatCard({
-  icon, iconBg, label, total, loading, rows, href,
+  icon,
+  iconBg,
+  label,
+  total,
+  loading,
+  rows,
+  href,
 }: {
   icon: React.ReactNode;
   iconBg: string;
   label: string;
   total: number;
   loading: boolean;
-  rows: { label: string; value: number; icon?: React.ReactNode; href: string }[];
+  rows: {
+    label: string;
+    value: number;
+    icon?: React.ReactNode;
+    href: string;
+  }[];
   href: string;
 }) {
   return (
     <div className="card flex flex-col gap-3">
       <div className="flex items-center gap-2">
         <div className={`rounded-lg ${iconBg} p-1.5`}>{icon}</div>
-        <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">{label}</span>
+        <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+          {label}
+        </span>
       </div>
       <p className="text-3xl font-bold text-foreground tabular-nums">
-        {loading ? '—' : total.toLocaleString()}
+        {loading ? "—" : total.toLocaleString()}
       </p>
       <div className="flex flex-col gap-2 border-t border-border pt-3">
         {rows.map((r) => (
           <div key={r.label} className="flex items-center justify-between">
-            <span className="flex items-center gap-1 text-xs text-muted-foreground">{r.icon}{r.label}</span>
-            <Link href={r.href} className="text-sm font-semibold text-foreground tabular-nums hover:text-primary transition-colors">
-              {loading ? '—' : r.value.toLocaleString()}
+            <span className="flex items-center gap-1 text-xs text-muted-foreground">
+              {r.icon}
+              {r.label}
+            </span>
+            <Link
+              href={r.href}
+              className="text-sm font-semibold text-foreground tabular-nums hover:text-primary transition-colors"
+            >
+              {loading ? "—" : r.value.toLocaleString()}
             </Link>
           </div>
         ))}
       </div>
-      <Link href={href} className="flex items-center gap-1 text-xs text-primary hover:underline mt-auto pt-1">
+      <Link
+        href={href}
+        className="flex items-center gap-1 text-xs text-primary hover:underline mt-auto pt-1"
+      >
         View all <ArrowRight className="h-3 w-3" />
       </Link>
     </div>
@@ -50,7 +79,12 @@ function StatCard({
 }
 
 function RevenueSection({
-  label, bookingCount, rows, subtotal, loading, renderRow,
+  label,
+  bookingCount,
+  rows,
+  subtotal,
+  loading,
+  renderRow,
 }: {
   label: React.ReactNode;
   bookingCount: number;
@@ -66,16 +100,22 @@ function RevenueSection({
           {label}
         </span>
         <span className="text-xs text-muted-foreground tabular-nums">
-          {loading ? '—' : bookingCount.toLocaleString()} bookings
+          {loading ? "—" : bookingCount.toLocaleString()} bookings
         </span>
       </div>
-      {rows.length === 0
-        ? <p className="text-xs text-muted-foreground py-1">No revenue yet</p>
-        : rows.map(renderRow)}
+      {rows.length === 0 ? (
+        <p className="text-xs text-muted-foreground py-1">No revenue yet</p>
+      ) : (
+        rows.map(renderRow)
+      )}
       {rows.length > 0 && (
         <div className="flex items-center justify-between rounded-md bg-muted/40 px-3 py-2 mt-1">
-          <span className="text-xs font-semibold text-muted-foreground">Subtotal</span>
-          <span className="text-sm font-bold text-foreground tabular-nums">{formatCurrency(subtotal, 'ETB')}</span>
+          <span className="text-xs font-semibold text-muted-foreground">
+            Subtotal
+          </span>
+          <span className="text-sm font-bold text-foreground tabular-nums">
+            {formatCurrency(subtotal, "ETB")}
+          </span>
         </div>
       )}
     </div>
@@ -84,19 +124,25 @@ function RevenueSection({
 
 function DashboardPageContent() {
   const { data: exchangeRates = [] } = useQuery<any[]>({
-    queryKey: ['currencies'],
-    queryFn: () => apiClient.get('/currencies'),
-    select: (d: any) => (Array.isArray(d) ? d : d?.data ?? d?.items ?? []),
+    queryKey: ["currencies"],
+    queryFn: () => apiClient.get("/currencies"),
+    select: (d: any) => (Array.isArray(d) ? d : (d?.data ?? d?.items ?? [])),
   });
 
   const toEtbRate = (currency: string): number | null => {
-    if (currency === 'ETB') return 1;
-    const r = exchangeRates.find((x: any) => x.fromCurrency === 'ETB' && x.toCurrency === currency);
+    if (currency === "ETB") return 1;
+    const r = exchangeRates.find(
+      (x: any) => x.fromCurrency === "ETB" && x.toCurrency === currency,
+    );
     return r ? 1 / r.rate : null;
   };
 
-  const { data: stats, isLoading: statsLoading, error: statsError } = useQuery({
-    queryKey: ['backoffice-stats'],
+  const {
+    data: stats,
+    isLoading: statsLoading,
+    error: statsError,
+  } = useQuery({
+    queryKey: ["backoffice-stats"],
     queryFn: dashboardApi.getBackofficeStats,
     retry: 1,
     staleTime: 30000,
@@ -104,7 +150,7 @@ function DashboardPageContent() {
   });
 
   const { data: paymentMethods } = useQuery({
-    queryKey: ['payment-methods'],
+    queryKey: ["payment-methods"],
     queryFn: dashboardApi.getPaymentMethods,
     retry: 1,
   });
@@ -121,20 +167,31 @@ function DashboardPageContent() {
   const packageGrand = calcGrand(packageRows);
   const overallGrand = normalGrand + packageGrand;
 
-  const renderRevenueRow = ({ currency, totalMinor }: { currency: string; totalMinor: number }) => {
+  const renderRevenueRow = ({
+    currency,
+    totalMinor,
+  }: {
+    currency: string;
+    totalMinor: number;
+  }) => {
     const rate = toEtbRate(currency);
     const etbMinor = rate !== null ? Math.round(totalMinor * rate) : null;
     return (
-      <div key={currency} className="flex items-center justify-between rounded-md bg-muted/20 px-3 py-2">
+      <div
+        key={currency}
+        className="flex items-center justify-between rounded-md bg-muted/20 px-3 py-2"
+      >
         <div className="flex items-center gap-1.5">
           <Banknote className="h-3.5 w-3.5 text-muted-foreground" />
-          <span className="text-sm font-medium text-foreground">{currency}</span>
+          <span className="text-sm font-medium text-foreground">
+            {currency}
+          </span>
         </div>
         <span className="text-sm font-semibold text-foreground tabular-nums">
           {formatCurrency(totalMinor, currency)}
-          {currency !== 'ETB' && etbMinor !== null && (
+          {currency !== "ETB" && etbMinor !== null && (
             <span className="ml-1.5 text-xs font-normal text-muted-foreground">
-              ({formatCurrency(etbMinor, 'ETB')})
+              ({formatCurrency(etbMinor, "ETB")})
             </span>
           )}
         </span>
@@ -147,15 +204,16 @@ function DashboardPageContent() {
       <div className="flex items-start justify-between">
         <div>
           <h1 className="text-3xl font-bold text-foreground">Dashboard</h1>
-          <p className="text-muted-foreground mt-1">Welcome back! Here&apos;s your operational summary.</p>
+          <p className="text-muted-foreground mt-1">
+            Welcome back! Here&apos;s your operational summary.
+          </p>
         </div>
         <Link
           href="/boarding"
-          className="flex items-center gap-2 rounded-lg border border-border bg-card px-3 py-2 text-sm font-medium text-foreground hover:bg-muted transition-colors"
-          title="Boarding / Gate Scan"
+          className="flex items-center gap-2 rounded-lg bg-emerald-600 hover:bg-emerald-700 text-white px-4 py-2 text-sm font-medium transition-colors"
         >
-          <ScanLine className="h-4 w-4 text-[rgb(20,113,76)]" />
-          <span className="hidden sm:inline">Boarding</span>
+          <ScanLine className="h-4 w-4" />
+          Boarding
         </Link>
       </div>
 
@@ -164,39 +222,42 @@ function DashboardPageContent() {
           <div className="flex items-center gap-2">
             <AlertCircle className="h-5 w-5 text-orange-600 dark:text-orange-400" />
             <div>
-              <h3 className="font-semibold text-orange-800 dark:text-orange-200">Some data may be outdated</h3>
-              <p className="text-sm text-orange-700 dark:text-orange-300">Unable to fetch live data. Showing cached or sample information.</p>
+              <h3 className="font-semibold text-orange-800 dark:text-orange-200">
+                Some data may be outdated
+              </h3>
+              <p className="text-sm text-orange-700 dark:text-orange-300">
+                Unable to fetch live data. Showing cached or sample information.
+              </p>
             </div>
           </div>
         </div>
       )}
 
       {/* Stat cards */}
-      <div className="grid grid-cols-1 gap-4 sm:grid-cols-3">
+      <div className="grid grid-cols-1 gap-4 sm:grid-cols-2">
         <StatCard
-          icon={<BookOpen className="h-4 w-4 text-blue-600 dark:text-blue-400" />}
+          icon={
+            <BookOpen className="h-4 w-4 text-blue-600 dark:text-blue-400" />
+          }
           iconBg="bg-blue-100 dark:bg-blue-900/30"
           label="Bookings"
           total={stats?.totalBookings ?? 0}
           loading={statsLoading}
           href="/bookings"
           rows={[
-            { label: 'Regular', value: stats?.totalNormalBookings ?? 0, href: '/bookings' },
-            { label: 'Package', value: stats?.totalPackageBookings ?? 0, href: '/package-bookings' },
-          ]}
-        />
-        <StatCard
-          icon={<Ticket className="h-4 w-4 text-emerald-600 dark:text-emerald-400" />}
-          iconBg="bg-emerald-100 dark:bg-emerald-900/30"
-          label="Tickets"
-          total={stats?.totalTickets ?? 0}
-          loading={statsLoading}
-          href="/tickets"
-          rows={[
-            { label: 'Regular', value: stats?.totalNormalTickets ?? 0, href: '/tickets' },
-            { label: 'Package', value: stats?.totalPackageTickets ?? 0, href: '/tickets' },
+            {
+              label: "Regular",
+              value: stats?.totalNormalBookings ?? 0,
+              href: "/bookings",
+            },
+            {
+              label: "Package",
+              value: stats?.totalPackageBookings ?? 0,
+              href: "/package-bookings",
+            },
           ]}
         />
+        {/* Tickets card hidden temporarily */}
 
         {/* Revenue card */}
         <div className="card flex flex-col gap-3">
@@ -204,26 +265,35 @@ function DashboardPageContent() {
             <div className="rounded-lg bg-amber-100 dark:bg-amber-900/30 p-1.5">
               <Banknote className="h-4 w-4 text-amber-600 dark:text-amber-400" />
             </div>
-            <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Revenue</span>
+            <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+              Revenue
+            </span>
           </div>
           {statsLoading ? (
             <p className="text-muted-foreground text-sm">Loading…</p>
           ) : (
             <>
               <p className="text-3xl font-bold text-emerald-600 dark:text-emerald-400 tabular-nums">
-                {formatCurrency(overallGrand, 'ETB')}
+                {formatCurrency(overallGrand, "ETB")}
               </p>
               <div className="flex flex-col gap-2 border-t border-border pt-3">
                 <div className="flex items-center justify-between">
                   <p className="text-xs text-muted-foreground">Regular</p>
-                  <p className="text-sm font-semibold text-foreground tabular-nums">{formatCurrency(normalGrand, 'ETB')}</p>
+                  <p className="text-sm font-semibold text-foreground tabular-nums">
+                    {formatCurrency(normalGrand, "ETB")}
+                  </p>
                 </div>
                 <div className="flex items-center justify-between">
                   <p className="text-xs text-muted-foreground">Package</p>
-                  <p className="text-sm font-semibold text-foreground tabular-nums">{formatCurrency(packageGrand, 'ETB')}</p>
+                  <p className="text-sm font-semibold text-foreground tabular-nums">
+                    {formatCurrency(packageGrand, "ETB")}
+                  </p>
                 </div>
               </div>
-              <Link href="/payments" className="flex items-center gap-1 text-xs text-primary hover:underline mt-auto pt-1">
+              <Link
+                href="/payments"
+                className="flex items-center gap-1 text-xs text-primary hover:underline mt-auto pt-1"
+              >
                 View payments <ArrowRight className="h-3 w-3" />
               </Link>
             </>
@@ -233,7 +303,9 @@ function DashboardPageContent() {
 
       {/* Revenue breakdown */}
       <div className="card">
-        <h2 className="text-sm font-semibold uppercase tracking-widest text-muted-foreground mb-4">Revenue Breakdown</h2>
+        <h2 className="text-sm font-semibold uppercase tracking-widest text-muted-foreground mb-4">
+          Revenue Breakdown
+        </h2>
         {statsLoading ? (
           <p className="text-muted-foreground text-sm">Loading…</p>
         ) : !normalRows.length && !packageRows.length ? (
@@ -263,12 +335,25 @@ function DashboardPageContent() {
       {/* Payment Methods Distribution */}
       {paymentMethods && paymentMethods.length > 0 && (
         <div className="card">
-          <h2 className="mb-4 text-lg font-semibold text-foreground">Payment Methods Distribution</h2>
+          <h2 className="mb-4 text-lg font-semibold text-foreground">
+            Payment Methods Distribution
+          </h2>
           <ResponsiveContainer width="100%" height={300}>
             <PieChart>
-              <Pie data={paymentMethods} dataKey="count" nameKey="method" cx="50%" cy="50%" outerRadius={80} label>
+              <Pie
+                data={paymentMethods}
+                dataKey="count"
+                nameKey="method"
+                cx="50%"
+                cy="50%"
+                outerRadius={80}
+                label
+              >
                 {paymentMethods.map((_: any, index: number) => (
-                  <Cell key={`cell-${index}`} fill={COLORS[index % COLORS.length]} />
+                  <Cell
+                    key={`cell-${index}`}
+                    fill={COLORS[index % COLORS.length]}
+                  />
                 ))}
               </Pie>
               <Tooltip />
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/overall/layout.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/overall/layout.tsx
new file mode 100644
index 000000000..5dd5937b8
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/overall/layout.tsx
@@ -0,0 +1,5 @@
+import DashboardLayout from '../../dashboard/layout';
+
+export default function OverallReportLayout({ children }: { children: React.ReactNode }) {
+  return <>{children}</>;
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/overall/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/overall/page.tsx
new file mode 100644
index 000000000..e715fbd71
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/overall/page.tsx
@@ -0,0 +1,517 @@
+'use client';
+
+import { useState } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { Download, TrendingUp, BookOpen, Banknote, Ticket } from 'lucide-react';
+import {
+  LineChart, Line, BarChart, Bar, XAxis, YAxis, CartesianGrid,
+  Tooltip, Legend, ResponsiveContainer, PieChart, Pie, Cell,
+} from 'recharts';
+import { bookingsApi } from '@/lib/api';
+import { dashboardApi } from '@/lib/api/dashboard';
+import { apiClient } from '@/lib/api-client';
+import { formatCurrency } from '@/lib/utils';
+import ActionButton from '@/components/ui/ActionButton';
+import Modal from '@/components/ui/Modal';
+
+const STATUS_COLORS = ['#3b82f6', '#10b981', '#f59e0b', '#ef4444'];
+
+function esc(s: string) {
+  return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+export default function ReportsPage() {
+  const [dateRange, setDateRange] = useState('30');
+  const [startDate, setStartDate] = useState('');
+  const [endDate, setEndDate] = useState('');
+  const [exportModalOpen, setExportModalOpen] = useState(false);
+  const [exportFormat, setExportFormat] = useState<'csv' | 'excel' | 'pdf'>('csv');
+
+  const getDateRange = () => {
+    const end = new Date();
+    end.setHours(23, 59, 59, 999);
+    const start = new Date();
+    switch (dateRange) {
+      case '7': start.setDate(end.getDate() - 7); break;
+      case '30': start.setDate(end.getDate() - 30); break;
+      case '90': start.setDate(end.getDate() - 90); break;
+      default:
+        if (startDate && endDate) return { startDate, endDate };
+    }
+    return {
+      startDate: start.toISOString().split('T')[0],
+      endDate: end.toISOString().split('T')[0],
+    };
+  };
+
+  const dates = getDateRange();
+
+  // Confirmed-ticket revenue — same source as dashboard
+  const { data: stats, isLoading: statsLoading } = useQuery({
+    queryKey: ['backoffice-stats'],
+    queryFn: dashboardApi.getBackofficeStats,
+    staleTime: 60000,
+  });
+
+  const { data: exchangeRates = [] } = useQuery<any[]>({
+    queryKey: ['currencies'],
+    queryFn: () => apiClient.get('/currencies'),
+    select: (d: any) => (Array.isArray(d) ? d : d?.data ?? d?.items ?? []),
+  });
+
+  const toEtbRate = (currency: string): number | null => {
+    if (currency === 'ETB') return 1;
+    const r = exchangeRates.find((x: any) => x.fromCurrency === 'ETB' && x.toCurrency === currency);
+    return r ? 1 / r.rate : null;
+  };
+
+  const calcGrand = (rows: { currency: string; totalMinor: number }[]) =>
+    rows.reduce((sum, { currency, totalMinor }) => {
+      const rate = toEtbRate(currency);
+      return rate !== null ? sum + Math.round(totalMinor * rate) : sum;
+    }, 0);
+
+  const normalRows = stats?.revenueByCurrency ?? [];
+  const packageRows = stats?.packageRevenueByCurrency ?? [];
+  const normalGrand = calcGrand(normalRows);
+  const packageGrand = calcGrand(packageRows);
+  const overallGrand = normalGrand + packageGrand;
+
+  // Bookings for charts / status distribution
+  const { data: bookingsData, isLoading: bookingsLoading } = useQuery({
+    queryKey: ['all-bookings'],
+    queryFn: () => bookingsApi.getAll({ pageSize: 1000 }),
+  });
+
+  const isLoading = statsLoading || bookingsLoading;
+
+  const allBookings: any[] = Array.isArray(bookingsData?.items) ? bookingsData.items : [];
+
+  const bookings = allBookings.filter((b: any) => {
+    const d = new Date(b.createdAt).toISOString().split('T')[0];
+    return d >= dates.startDate && d <= dates.endDate;
+  });
+
+  const confirmedBookings = bookings.filter((b: any) => b.status !== 'CANCELLED' && b.status !== 'REFUNDED');
+
+  const byDate = confirmedBookings.reduce((acc: Record<string, any>, b: any) => {
+    const date = new Date(b.createdAt).toISOString().split('T')[0];
+    if (!acc[date]) acc[date] = { totalMinor: 0, count: 0 };
+    acc[date].totalMinor += b.totalMinor || 0;
+    acc[date].count += 1;
+    return acc;
+  }, {});
+
+  const chartData = Object.entries(byDate)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([date, d]: [string, any]) => ({
+      date: new Date(date).toLocaleDateString('en-US', { month: 'short', day: 'numeric' }),
+      revenue: (d.totalMinor || 0) / 100,
+      bookings: d.count || 0,
+    }));
+
+  const avgDailyRevenue = chartData.length > 0 ? Math.round(overallGrand / 100 / chartData.length) : 0;
+
+  const REPORT_COLS = ['Date', 'Revenue (ETB)', 'Confirmed Bookings'];
+
+  const doExport = () => {
+    if (!chartData.length) { alert('No data to export'); return; }
+    const rows = chartData.map(r => [r.date, String(Math.round(r.revenue)), String(r.bookings)]);
+    const dateStr = new Date().toISOString().split('T')[0];
+
+    if (exportFormat === 'pdf') {
+      const w = window.open('', '_blank')!;
+      const thead = REPORT_COLS.map(h => `<th>${esc(h)}</th>`).join('');
+      const tbody = rows.map(r => `<tr>${r.map(v => `<td>${esc(v)}</td>`).join('')}</tr>`).join('');
+      w.document.write(
+        `<!DOCTYPE html><html><head><title>Revenue Report</title>` +
+        `<style>body{font-family:sans-serif;font-size:11px}table{border-collapse:collapse;width:100%}` +
+        `th,td{border:1px solid #ccc;padding:4px 8px}th{background:#10b981;color:#fff}</style></head><body>` +
+        `<h2>Revenue Report — ${esc(dates.startDate)} to ${esc(dates.endDate)}</h2>` +
+        `<p>Total Revenue: ${esc(formatCurrency(overallGrand, 'ETB'))} | ` +
+        `Bookings: ${esc(String(stats?.totalBookings ?? 0))} | ` +
+        `Tickets: ${esc(String(stats?.totalTickets ?? 0))}</p>` +
+        `<table><thead><tr>${thead}</tr></thead><tbody>${tbody}</tbody></table></body></html>`
+      );
+      w.document.close(); w.print();
+    } else if (exportFormat === 'excel') {
+      const tsv = [REPORT_COLS.join('\t'), ...rows.map(r => r.join('\t'))].join('\n');
+      const blob = new Blob([tsv], { type: 'application/vnd.ms-excel' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a'); a.href = url; a.download = `revenue-report-${dateStr}.xls`; a.click(); URL.revokeObjectURL(url);
+    } else {
+      const csv = [REPORT_COLS.map(h => `"${h}"`).join(','), ...rows.map(r => r.map(v => `"${v}"`).join(','))].join('\n');
+      const blob = new Blob([csv], { type: 'text/csv' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a'); a.href = url; a.download = `revenue-report-${dateStr}.csv`; a.click(); URL.revokeObjectURL(url);
+    }
+    setExportModalOpen(false);
+  };
+
+  const renderCurrencyRow = ({ currency, totalMinor }: { currency: string; totalMinor: number }) => {
+    const rate = toEtbRate(currency);
+    const etbMinor = rate !== null ? Math.round(totalMinor * rate) : null;
+    return (
+      <div key={currency} className="flex items-center justify-between rounded-md bg-muted/20 px-3 py-2">
+        <div className="flex items-center gap-1.5">
+          <Banknote className="h-3.5 w-3.5 text-muted-foreground" />
+          <span className="text-sm font-medium">{currency}</span>
+        </div>
+        <span className="text-sm font-semibold tabular-nums">
+          {formatCurrency(totalMinor, currency)}
+          {currency !== 'ETB' && etbMinor !== null && (
+            <span className="ml-1.5 text-xs font-normal text-muted-foreground">
+              ({formatCurrency(etbMinor, 'ETB')})
+            </span>
+          )}
+        </span>
+      </div>
+    );
+  };
+
+  return (
+    <div className="space-y-6">
+      <div>
+        <h1 className="text-3xl font-bold text-foreground">Reports & Analytics</h1>
+        <p className="text-muted-foreground mt-1">Revenue figures reflect confirmed tickets only</p>
+      </div>
+
+      {/* Date Range Selector */}
+      <div className="card">
+        <div className="flex items-end gap-4 flex-wrap">
+          <div>
+            <label className="label">Date Range</label>
+            <select className="input" value={dateRange} onChange={(e) => setDateRange(e.target.value)} disabled={isLoading}>
+              <option value="7">Last 7 Days</option>
+              <option value="30">Last 30 Days</option>
+              <option value="90">Last 90 Days</option>
+              <option value="custom">Custom Range</option>
+            </select>
+          </div>
+          {dateRange === 'custom' && (
+            <>
+              <div>
+                <label className="label">Start Date</label>
+                <input type="date" className="input" value={startDate} onChange={(e) => setStartDate(e.target.value)} disabled={isLoading} />
+              </div>
+              <div>
+                <label className="label">End Date</label>
+                <input type="date" className="input" value={endDate} onChange={(e) => setEndDate(e.target.value)} disabled={isLoading} />
+              </div>
+            </>
+          )}
+          <ActionButton icon={Download} variant="secondary" disabled={isLoading} onClick={() => setExportModalOpen(true)}>
+            Export
+          </ActionButton>
+        </div>
+        {isLoading && <p className="text-xs text-muted-foreground mt-2">Loading…</p>}
+      </div>
+
+      {/* Key Metrics */}
+      <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
+        {/* Total Revenue */}
+        <div className="card flex flex-col gap-1">
+          <div className="flex items-center justify-between">
+            <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Total Revenue</p>
+            <div className="rounded-lg bg-amber-100 dark:bg-amber-900/30 p-1.5">
+              <Banknote className="h-4 w-4 text-amber-600 dark:text-amber-400" />
+            </div>
+          </div>
+          <p className="text-2xl font-bold text-emerald-600 dark:text-emerald-400 tabular-nums mt-1">
+            {statsLoading ? '—' : formatCurrency(overallGrand, 'ETB')}
+          </p>
+          <div className="flex flex-col gap-1 border-t border-border pt-2 mt-1">
+            <div className="flex justify-between text-xs">
+              <span className="text-muted-foreground">Regular</span>
+              <span className="font-semibold tabular-nums">{statsLoading ? '—' : formatCurrency(normalGrand, 'ETB')}</span>
+            </div>
+            <div className="flex justify-between text-xs">
+              <span className="text-muted-foreground">Package</span>
+              <span className="font-semibold tabular-nums">{statsLoading ? '—' : formatCurrency(packageGrand, 'ETB')}</span>
+            </div>
+          </div>
+        </div>
+
+        {/* Total Bookings */}
+        <div className="card flex flex-col gap-1">
+          <div className="flex items-center justify-between">
+            <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Total Bookings</p>
+            <div className="rounded-lg bg-blue-100 dark:bg-blue-900/30 p-1.5">
+              <BookOpen className="h-4 w-4 text-blue-600 dark:text-blue-400" />
+            </div>
+          </div>
+          <p className="text-2xl font-bold tabular-nums mt-1">
+            {statsLoading ? '—' : (stats?.totalBookings ?? 0).toLocaleString()}
+          </p>
+          <div className="flex flex-col gap-1 border-t border-border pt-2 mt-1">
+            <div className="flex justify-between text-xs">
+              <span className="text-muted-foreground">Regular</span>
+              <span className="font-semibold tabular-nums">{statsLoading ? '—' : (stats?.totalNormalBookings ?? 0).toLocaleString()}</span>
+            </div>
+            <div className="flex justify-between text-xs">
+              <span className="text-muted-foreground">Package</span>
+              <span className="font-semibold tabular-nums">{statsLoading ? '—' : (stats?.totalPackageBookings ?? 0).toLocaleString()}</span>
+            </div>
+          </div>
+        </div>
+
+        {/* Total Tickets */}
+        <div className="card flex flex-col gap-1">
+          <div className="flex items-center justify-between">
+            <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Total Tickets</p>
+            <div className="rounded-lg bg-emerald-100 dark:bg-emerald-900/30 p-1.5">
+              <Ticket className="h-4 w-4 text-emerald-600 dark:text-emerald-400" />
+            </div>
+          </div>
+          <p className="text-2xl font-bold tabular-nums mt-1">
+            {statsLoading ? '—' : (stats?.totalTickets ?? 0).toLocaleString()}
+          </p>
+          <div className="flex flex-col gap-1 border-t border-border pt-2 mt-1">
+            <div className="flex justify-between text-xs">
+              <span className="text-muted-foreground">Regular</span>
+              <span className="font-semibold tabular-nums">{statsLoading ? '—' : (stats?.totalNormalTickets ?? 0).toLocaleString()}</span>
+            </div>
+            <div className="flex justify-between text-xs">
+              <span className="text-muted-foreground">Package</span>
+              <span className="font-semibold tabular-nums">{statsLoading ? '—' : (stats?.totalPackageTickets ?? 0).toLocaleString()}</span>
+            </div>
+          </div>
+        </div>
+
+        {/* Avg Daily Revenue */}
+        <div className="card flex flex-col gap-1">
+          <div className="flex items-center justify-between">
+            <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Avg. Daily Revenue</p>
+            <div className="rounded-lg bg-purple-100 dark:bg-purple-900/30 p-1.5">
+              <TrendingUp className="h-4 w-4 text-purple-600 dark:text-purple-400" />
+            </div>
+          </div>
+          <p className="text-2xl font-bold tabular-nums mt-1">
+            {isLoading ? '—' : formatCurrency(avgDailyRevenue * 100, 'ETB')}
+          </p>
+          <p className="text-xs text-muted-foreground mt-auto pt-2 border-t border-border">
+            Over {chartData.length} active day{chartData.length !== 1 ? 's' : ''} in range
+          </p>
+        </div>
+      </div>
+
+      {/* Revenue Breakdown by Currency */}
+      <div className="card">
+        <h2 className="text-sm font-semibold uppercase tracking-widest text-muted-foreground mb-4">
+          Revenue Breakdown — Confirmed Tickets
+        </h2>
+        {statsLoading ? (
+          <p className="text-sm text-muted-foreground">Loading…</p>
+        ) : !normalRows.length && !packageRows.length ? (
+          <p className="text-sm text-muted-foreground">No revenue data yet.</p>
+        ) : (
+          <div className="grid grid-cols-1 sm:grid-cols-2 gap-6">
+            {/* Regular */}
+            <div className="flex flex-col gap-2">
+              <div className="flex items-center justify-between mb-1">
+                <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Regular</span>
+                <span className="text-xs text-muted-foreground tabular-nums">
+                  {(stats?.totalNormalBookings ?? 0).toLocaleString()} bookings · {(stats?.totalNormalTickets ?? 0).toLocaleString()} tickets
+                </span>
+              </div>
+              {normalRows.length === 0
+                ? <p className="text-xs text-muted-foreground py-1">No revenue yet</p>
+                : normalRows.map(renderCurrencyRow)}
+              {normalRows.length > 0 && (
+                <div className="flex items-center justify-between rounded-md bg-muted/40 px-3 py-2 mt-1">
+                  <span className="text-xs font-semibold text-muted-foreground">Subtotal</span>
+                  <span className="text-sm font-bold tabular-nums">{formatCurrency(normalGrand, 'ETB')}</span>
+                </div>
+              )}
+            </div>
+
+            {/* Package */}
+            <div className="flex flex-col gap-2">
+              <div className="flex items-center justify-between mb-1">
+                <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Package</span>
+                <span className="text-xs text-muted-foreground tabular-nums">
+                  {(stats?.totalPackageBookings ?? 0).toLocaleString()} bookings · {(stats?.totalPackageTickets ?? 0).toLocaleString()} tickets
+                </span>
+              </div>
+              {packageRows.length === 0
+                ? <p className="text-xs text-muted-foreground py-1">No revenue yet</p>
+                : packageRows.map(renderCurrencyRow)}
+              {packageRows.length > 0 && (
+                <div className="flex items-center justify-between rounded-md bg-muted/40 px-3 py-2 mt-1">
+                  <span className="text-xs font-semibold text-muted-foreground">Subtotal</span>
+                  <span className="text-sm font-bold tabular-nums">{formatCurrency(packageGrand, 'ETB')}</span>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+        {!statsLoading && (normalRows.length > 0 || packageRows.length > 0) && (
+          <div className="flex items-center justify-between rounded-lg border border-border bg-muted/30 px-4 py-3 mt-4">
+            <span className="text-sm font-semibold text-muted-foreground">Grand Total (ETB equivalent)</span>
+            <span className="text-lg font-bold text-emerald-600 dark:text-emerald-400 tabular-nums">
+              {formatCurrency(overallGrand, 'ETB')}
+            </span>
+          </div>
+        )}
+      </div>
+
+      {/* Charts */}
+      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+        {/* Revenue Trend */}
+        <div className="card">
+          <h3 className="text-base font-semibold mb-4">
+            Revenue Trend{' '}
+            <span className="text-xs font-normal text-muted-foreground">(confirmed, ETB)</span>
+          </h3>
+          {chartData.length > 0 ? (
+            <ResponsiveContainer width="100%" height={280}>
+              <LineChart data={chartData}>
+                <CartesianGrid strokeDasharray="3 3" stroke="#e5e7eb" />
+                <XAxis dataKey="date" tick={{ fontSize: 11 }} />
+                <YAxis tick={{ fontSize: 11 }} />
+                <Tooltip formatter={(value: number) => [`ETB ${Math.round(value).toLocaleString()}`, 'Revenue']} />
+                <Legend />
+                <Line type="monotone" dataKey="revenue" stroke="#10b981" dot={{ r: 4 }} activeDot={{ r: 6 }} strokeWidth={2} />
+              </LineChart>
+            </ResponsiveContainer>
+          ) : (
+            <div className="h-[280px] flex items-center justify-center text-muted-foreground text-sm">
+              No data for selected range
+            </div>
+          )}
+        </div>
+
+        {/* Daily Confirmed Bookings */}
+        <div className="card">
+          <h3 className="text-base font-semibold mb-4">Daily Confirmed Bookings</h3>
+          {chartData.length > 0 ? (
+            <ResponsiveContainer width="100%" height={280}>
+              <BarChart data={chartData}>
+                <CartesianGrid strokeDasharray="3 3" stroke="#e5e7eb" />
+                <XAxis dataKey="date" tick={{ fontSize: 11 }} />
+                <YAxis tick={{ fontSize: 11 }} />
+                <Tooltip />
+                <Bar dataKey="bookings" fill="#3b82f6" radius={[3, 3, 0, 0]} />
+              </BarChart>
+            </ResponsiveContainer>
+          ) : (
+            <div className="h-[280px] flex items-center justify-center text-muted-foreground text-sm">
+              No data for selected range
+            </div>
+          )}
+        </div>
+
+        {/* Booking Status Distribution */}
+        <div className="card">
+          <h3 className="text-base font-semibold mb-4">Booking Status Distribution</h3>
+          {bookings.length > 0 ? (
+            <ResponsiveContainer width="100%" height={280}>
+              <PieChart>
+                <Pie
+                  data={[
+                    { name: 'Confirmed', value: bookings.filter((b: any) => b.status === 'CONFIRMED').length },
+                    { name: 'Boarded', value: bookings.filter((b: any) => b.status === 'BOARDED').length },
+                    { name: 'Cancelled', value: bookings.filter((b: any) => b.status === 'CANCELLED').length },
+                    { name: 'Other', value: bookings.filter((b: any) => !['CONFIRMED', 'BOARDED', 'CANCELLED'].includes(b.status)).length },
+                  ].filter(d => d.value > 0)}
+                  cx="50%" cy="50%"
+                  labelLine={false}
+                  label={({ name, value }) => `${name}: ${value}`}
+                  outerRadius={100}
+                  dataKey="value"
+                >
+                  {STATUS_COLORS.map((color, idx) => <Cell key={idx} fill={color} />)}
+                </Pie>
+                <Tooltip />
+              </PieChart>
+            </ResponsiveContainer>
+          ) : (
+            <div className="h-[280px] flex items-center justify-center text-muted-foreground text-sm">
+              No data for selected range
+            </div>
+          )}
+        </div>
+
+        {/* Payment Methods */}
+        <div className="card">
+          <h3 className="text-base font-semibold mb-4">Payment Methods</h3>
+          {bookings.length > 0 ? (
+            <div className="space-y-3 pt-1">
+              {(Object.entries(
+                bookings.reduce((acc: Record<string, number>, b: any) => {
+                  const method = b.paymentIntent?.method || 'Unknown';
+                  acc[method] = (acc[method] || 0) + 1;
+                  return acc;
+                }, {} as Record<string, number>)
+              ) as [string, number][])
+                .sort(([, a], [, b]) => b - a)
+                .slice(0, 6)
+                .map(([method, count]) => {
+                  const pct = bookings.length > 0 ? Math.round((count / bookings.length) * 100) : 0;
+                  return (
+                    <div key={method} className="flex items-center gap-3">
+                      <span className="text-sm w-32 shrink-0 capitalize">{method.toLowerCase().replace(/_/g, ' ')}</span>
+                      <div className="flex-1 bg-muted rounded-full h-2">
+                        <div className="bg-primary h-2 rounded-full" style={{ width: `${pct}%` }} />
+                      </div>
+                      <span className="text-sm font-semibold tabular-nums w-8 text-right">{count}</span>
+                    </div>
+                  );
+                })}
+            </div>
+          ) : (
+            <div className="h-[280px] flex items-center justify-center text-muted-foreground text-sm">
+              No data for selected range
+            </div>
+          )}
+        </div>
+      </div>
+
+      {/* Summary */}
+      <div className="card">
+        <h3 className="text-base font-semibold mb-4">Summary</h3>
+        <div className="grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-6 gap-3">
+          {[
+            { label: 'Active Days', value: chartData.length, fromStats: false },
+            { label: 'Confirmed', value: bookings.filter((b: any) => b.status === 'CONFIRMED').length, fromStats: false },
+            { label: 'Boarded', value: bookings.filter((b: any) => b.status === 'BOARDED').length, fromStats: false },
+            { label: 'Cancelled', value: bookings.filter((b: any) => b.status === 'CANCELLED').length, fromStats: false },
+            { label: 'Regular Bookings', value: stats?.totalNormalBookings ?? 0, fromStats: true },
+            { label: 'Package Bookings', value: stats?.totalPackageBookings ?? 0, fromStats: true },
+          ].map(({ label, value, fromStats }) => (
+            <div key={label} className="border border-border rounded-lg p-3 text-center">
+              <p className="text-xs text-muted-foreground">{label}</p>
+              <p className="text-xl font-bold mt-1 tabular-nums">
+                {fromStats && statsLoading ? '—' : value.toLocaleString()}
+              </p>
+            </div>
+          ))}
+        </div>
+      </div>
+
+      {/* Export Modal */}
+      <Modal isOpen={exportModalOpen} onClose={() => setExportModalOpen(false)} title="Export Revenue Report" size="sm">
+        <div className="space-y-4">
+          <p className="text-sm text-muted-foreground">
+            Exports daily confirmed-booking revenue for the selected date range. Cancelled and refunded bookings are excluded.
+          </p>
+          <div>
+            <p className="text-sm font-medium mb-2">Format</p>
+            <div className="flex gap-3">
+              {(['csv', 'excel', 'pdf'] as const).map(fmt => (
+                <label key={fmt} className="flex items-center gap-2 cursor-pointer">
+                  <input type="radio" name="reportExportFormat" value={fmt} checked={exportFormat === fmt} onChange={() => setExportFormat(fmt)} className="w-4 h-4" />
+                  <span className="text-sm font-medium">{fmt === 'excel' ? 'Excel (.xls)' : fmt === 'pdf' ? 'PDF (Print)' : 'CSV'}</span>
+                </label>
+              ))}
+            </div>
+          </div>
+          <div className="flex justify-end gap-2 pt-4 border-t">
+            <ActionButton variant="secondary" onClick={() => setExportModalOpen(false)}>Cancel</ActionButton>
+            <ActionButton onClick={doExport}>Export</ActionButton>
+          </div>
+        </div>
+      </Modal>
+    </div>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/page.tsx
index e715fbd71..cb47f6c07 100644
--- a/apps/edr-passenger-web/backoffice/src/app/reports/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/page.tsx
@@ -1,517 +1,5 @@
-'use client';
-
-import { useState } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { Download, TrendingUp, BookOpen, Banknote, Ticket } from 'lucide-react';
-import {
-  LineChart, Line, BarChart, Bar, XAxis, YAxis, CartesianGrid,
-  Tooltip, Legend, ResponsiveContainer, PieChart, Pie, Cell,
-} from 'recharts';
-import { bookingsApi } from '@/lib/api';
-import { dashboardApi } from '@/lib/api/dashboard';
-import { apiClient } from '@/lib/api-client';
-import { formatCurrency } from '@/lib/utils';
-import ActionButton from '@/components/ui/ActionButton';
-import Modal from '@/components/ui/Modal';
-
-const STATUS_COLORS = ['#3b82f6', '#10b981', '#f59e0b', '#ef4444'];
-
-function esc(s: string) {
-  return String(s).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-}
+import { redirect } from 'next/navigation';
 
 export default function ReportsPage() {
-  const [dateRange, setDateRange] = useState('30');
-  const [startDate, setStartDate] = useState('');
-  const [endDate, setEndDate] = useState('');
-  const [exportModalOpen, setExportModalOpen] = useState(false);
-  const [exportFormat, setExportFormat] = useState<'csv' | 'excel' | 'pdf'>('csv');
-
-  const getDateRange = () => {
-    const end = new Date();
-    end.setHours(23, 59, 59, 999);
-    const start = new Date();
-    switch (dateRange) {
-      case '7': start.setDate(end.getDate() - 7); break;
-      case '30': start.setDate(end.getDate() - 30); break;
-      case '90': start.setDate(end.getDate() - 90); break;
-      default:
-        if (startDate && endDate) return { startDate, endDate };
-    }
-    return {
-      startDate: start.toISOString().split('T')[0],
-      endDate: end.toISOString().split('T')[0],
-    };
-  };
-
-  const dates = getDateRange();
-
-  // Confirmed-ticket revenue — same source as dashboard
-  const { data: stats, isLoading: statsLoading } = useQuery({
-    queryKey: ['backoffice-stats'],
-    queryFn: dashboardApi.getBackofficeStats,
-    staleTime: 60000,
-  });
-
-  const { data: exchangeRates = [] } = useQuery<any[]>({
-    queryKey: ['currencies'],
-    queryFn: () => apiClient.get('/currencies'),
-    select: (d: any) => (Array.isArray(d) ? d : d?.data ?? d?.items ?? []),
-  });
-
-  const toEtbRate = (currency: string): number | null => {
-    if (currency === 'ETB') return 1;
-    const r = exchangeRates.find((x: any) => x.fromCurrency === 'ETB' && x.toCurrency === currency);
-    return r ? 1 / r.rate : null;
-  };
-
-  const calcGrand = (rows: { currency: string; totalMinor: number }[]) =>
-    rows.reduce((sum, { currency, totalMinor }) => {
-      const rate = toEtbRate(currency);
-      return rate !== null ? sum + Math.round(totalMinor * rate) : sum;
-    }, 0);
-
-  const normalRows = stats?.revenueByCurrency ?? [];
-  const packageRows = stats?.packageRevenueByCurrency ?? [];
-  const normalGrand = calcGrand(normalRows);
-  const packageGrand = calcGrand(packageRows);
-  const overallGrand = normalGrand + packageGrand;
-
-  // Bookings for charts / status distribution
-  const { data: bookingsData, isLoading: bookingsLoading } = useQuery({
-    queryKey: ['all-bookings'],
-    queryFn: () => bookingsApi.getAll({ pageSize: 1000 }),
-  });
-
-  const isLoading = statsLoading || bookingsLoading;
-
-  const allBookings: any[] = Array.isArray(bookingsData?.items) ? bookingsData.items : [];
-
-  const bookings = allBookings.filter((b: any) => {
-    const d = new Date(b.createdAt).toISOString().split('T')[0];
-    return d >= dates.startDate && d <= dates.endDate;
-  });
-
-  const confirmedBookings = bookings.filter((b: any) => b.status !== 'CANCELLED' && b.status !== 'REFUNDED');
-
-  const byDate = confirmedBookings.reduce((acc: Record<string, any>, b: any) => {
-    const date = new Date(b.createdAt).toISOString().split('T')[0];
-    if (!acc[date]) acc[date] = { totalMinor: 0, count: 0 };
-    acc[date].totalMinor += b.totalMinor || 0;
-    acc[date].count += 1;
-    return acc;
-  }, {});
-
-  const chartData = Object.entries(byDate)
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([date, d]: [string, any]) => ({
-      date: new Date(date).toLocaleDateString('en-US', { month: 'short', day: 'numeric' }),
-      revenue: (d.totalMinor || 0) / 100,
-      bookings: d.count || 0,
-    }));
-
-  const avgDailyRevenue = chartData.length > 0 ? Math.round(overallGrand / 100 / chartData.length) : 0;
-
-  const REPORT_COLS = ['Date', 'Revenue (ETB)', 'Confirmed Bookings'];
-
-  const doExport = () => {
-    if (!chartData.length) { alert('No data to export'); return; }
-    const rows = chartData.map(r => [r.date, String(Math.round(r.revenue)), String(r.bookings)]);
-    const dateStr = new Date().toISOString().split('T')[0];
-
-    if (exportFormat === 'pdf') {
-      const w = window.open('', '_blank')!;
-      const thead = REPORT_COLS.map(h => `<th>${esc(h)}</th>`).join('');
-      const tbody = rows.map(r => `<tr>${r.map(v => `<td>${esc(v)}</td>`).join('')}</tr>`).join('');
-      w.document.write(
-        `<!DOCTYPE html><html><head><title>Revenue Report</title>` +
-        `<style>body{font-family:sans-serif;font-size:11px}table{border-collapse:collapse;width:100%}` +
-        `th,td{border:1px solid #ccc;padding:4px 8px}th{background:#10b981;color:#fff}</style></head><body>` +
-        `<h2>Revenue Report — ${esc(dates.startDate)} to ${esc(dates.endDate)}</h2>` +
-        `<p>Total Revenue: ${esc(formatCurrency(overallGrand, 'ETB'))} | ` +
-        `Bookings: ${esc(String(stats?.totalBookings ?? 0))} | ` +
-        `Tickets: ${esc(String(stats?.totalTickets ?? 0))}</p>` +
-        `<table><thead><tr>${thead}</tr></thead><tbody>${tbody}</tbody></table></body></html>`
-      );
-      w.document.close(); w.print();
-    } else if (exportFormat === 'excel') {
-      const tsv = [REPORT_COLS.join('\t'), ...rows.map(r => r.join('\t'))].join('\n');
-      const blob = new Blob([tsv], { type: 'application/vnd.ms-excel' });
-      const url = URL.createObjectURL(blob);
-      const a = document.createElement('a'); a.href = url; a.download = `revenue-report-${dateStr}.xls`; a.click(); URL.revokeObjectURL(url);
-    } else {
-      const csv = [REPORT_COLS.map(h => `"${h}"`).join(','), ...rows.map(r => r.map(v => `"${v}"`).join(','))].join('\n');
-      const blob = new Blob([csv], { type: 'text/csv' });
-      const url = URL.createObjectURL(blob);
-      const a = document.createElement('a'); a.href = url; a.download = `revenue-report-${dateStr}.csv`; a.click(); URL.revokeObjectURL(url);
-    }
-    setExportModalOpen(false);
-  };
-
-  const renderCurrencyRow = ({ currency, totalMinor }: { currency: string; totalMinor: number }) => {
-    const rate = toEtbRate(currency);
-    const etbMinor = rate !== null ? Math.round(totalMinor * rate) : null;
-    return (
-      <div key={currency} className="flex items-center justify-between rounded-md bg-muted/20 px-3 py-2">
-        <div className="flex items-center gap-1.5">
-          <Banknote className="h-3.5 w-3.5 text-muted-foreground" />
-          <span className="text-sm font-medium">{currency}</span>
-        </div>
-        <span className="text-sm font-semibold tabular-nums">
-          {formatCurrency(totalMinor, currency)}
-          {currency !== 'ETB' && etbMinor !== null && (
-            <span className="ml-1.5 text-xs font-normal text-muted-foreground">
-              ({formatCurrency(etbMinor, 'ETB')})
-            </span>
-          )}
-        </span>
-      </div>
-    );
-  };
-
-  return (
-    <div className="space-y-6">
-      <div>
-        <h1 className="text-3xl font-bold text-foreground">Reports & Analytics</h1>
-        <p className="text-muted-foreground mt-1">Revenue figures reflect confirmed tickets only</p>
-      </div>
-
-      {/* Date Range Selector */}
-      <div className="card">
-        <div className="flex items-end gap-4 flex-wrap">
-          <div>
-            <label className="label">Date Range</label>
-            <select className="input" value={dateRange} onChange={(e) => setDateRange(e.target.value)} disabled={isLoading}>
-              <option value="7">Last 7 Days</option>
-              <option value="30">Last 30 Days</option>
-              <option value="90">Last 90 Days</option>
-              <option value="custom">Custom Range</option>
-            </select>
-          </div>
-          {dateRange === 'custom' && (
-            <>
-              <div>
-                <label className="label">Start Date</label>
-                <input type="date" className="input" value={startDate} onChange={(e) => setStartDate(e.target.value)} disabled={isLoading} />
-              </div>
-              <div>
-                <label className="label">End Date</label>
-                <input type="date" className="input" value={endDate} onChange={(e) => setEndDate(e.target.value)} disabled={isLoading} />
-              </div>
-            </>
-          )}
-          <ActionButton icon={Download} variant="secondary" disabled={isLoading} onClick={() => setExportModalOpen(true)}>
-            Export
-          </ActionButton>
-        </div>
-        {isLoading && <p className="text-xs text-muted-foreground mt-2">Loading…</p>}
-      </div>
-
-      {/* Key Metrics */}
-      <div className="grid grid-cols-1 sm:grid-cols-2 lg:grid-cols-4 gap-4">
-        {/* Total Revenue */}
-        <div className="card flex flex-col gap-1">
-          <div className="flex items-center justify-between">
-            <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Total Revenue</p>
-            <div className="rounded-lg bg-amber-100 dark:bg-amber-900/30 p-1.5">
-              <Banknote className="h-4 w-4 text-amber-600 dark:text-amber-400" />
-            </div>
-          </div>
-          <p className="text-2xl font-bold text-emerald-600 dark:text-emerald-400 tabular-nums mt-1">
-            {statsLoading ? '—' : formatCurrency(overallGrand, 'ETB')}
-          </p>
-          <div className="flex flex-col gap-1 border-t border-border pt-2 mt-1">
-            <div className="flex justify-between text-xs">
-              <span className="text-muted-foreground">Regular</span>
-              <span className="font-semibold tabular-nums">{statsLoading ? '—' : formatCurrency(normalGrand, 'ETB')}</span>
-            </div>
-            <div className="flex justify-between text-xs">
-              <span className="text-muted-foreground">Package</span>
-              <span className="font-semibold tabular-nums">{statsLoading ? '—' : formatCurrency(packageGrand, 'ETB')}</span>
-            </div>
-          </div>
-        </div>
-
-        {/* Total Bookings */}
-        <div className="card flex flex-col gap-1">
-          <div className="flex items-center justify-between">
-            <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Total Bookings</p>
-            <div className="rounded-lg bg-blue-100 dark:bg-blue-900/30 p-1.5">
-              <BookOpen className="h-4 w-4 text-blue-600 dark:text-blue-400" />
-            </div>
-          </div>
-          <p className="text-2xl font-bold tabular-nums mt-1">
-            {statsLoading ? '—' : (stats?.totalBookings ?? 0).toLocaleString()}
-          </p>
-          <div className="flex flex-col gap-1 border-t border-border pt-2 mt-1">
-            <div className="flex justify-between text-xs">
-              <span className="text-muted-foreground">Regular</span>
-              <span className="font-semibold tabular-nums">{statsLoading ? '—' : (stats?.totalNormalBookings ?? 0).toLocaleString()}</span>
-            </div>
-            <div className="flex justify-between text-xs">
-              <span className="text-muted-foreground">Package</span>
-              <span className="font-semibold tabular-nums">{statsLoading ? '—' : (stats?.totalPackageBookings ?? 0).toLocaleString()}</span>
-            </div>
-          </div>
-        </div>
-
-        {/* Total Tickets */}
-        <div className="card flex flex-col gap-1">
-          <div className="flex items-center justify-between">
-            <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Total Tickets</p>
-            <div className="rounded-lg bg-emerald-100 dark:bg-emerald-900/30 p-1.5">
-              <Ticket className="h-4 w-4 text-emerald-600 dark:text-emerald-400" />
-            </div>
-          </div>
-          <p className="text-2xl font-bold tabular-nums mt-1">
-            {statsLoading ? '—' : (stats?.totalTickets ?? 0).toLocaleString()}
-          </p>
-          <div className="flex flex-col gap-1 border-t border-border pt-2 mt-1">
-            <div className="flex justify-between text-xs">
-              <span className="text-muted-foreground">Regular</span>
-              <span className="font-semibold tabular-nums">{statsLoading ? '—' : (stats?.totalNormalTickets ?? 0).toLocaleString()}</span>
-            </div>
-            <div className="flex justify-between text-xs">
-              <span className="text-muted-foreground">Package</span>
-              <span className="font-semibold tabular-nums">{statsLoading ? '—' : (stats?.totalPackageTickets ?? 0).toLocaleString()}</span>
-            </div>
-          </div>
-        </div>
-
-        {/* Avg Daily Revenue */}
-        <div className="card flex flex-col gap-1">
-          <div className="flex items-center justify-between">
-            <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Avg. Daily Revenue</p>
-            <div className="rounded-lg bg-purple-100 dark:bg-purple-900/30 p-1.5">
-              <TrendingUp className="h-4 w-4 text-purple-600 dark:text-purple-400" />
-            </div>
-          </div>
-          <p className="text-2xl font-bold tabular-nums mt-1">
-            {isLoading ? '—' : formatCurrency(avgDailyRevenue * 100, 'ETB')}
-          </p>
-          <p className="text-xs text-muted-foreground mt-auto pt-2 border-t border-border">
-            Over {chartData.length} active day{chartData.length !== 1 ? 's' : ''} in range
-          </p>
-        </div>
-      </div>
-
-      {/* Revenue Breakdown by Currency */}
-      <div className="card">
-        <h2 className="text-sm font-semibold uppercase tracking-widest text-muted-foreground mb-4">
-          Revenue Breakdown — Confirmed Tickets
-        </h2>
-        {statsLoading ? (
-          <p className="text-sm text-muted-foreground">Loading…</p>
-        ) : !normalRows.length && !packageRows.length ? (
-          <p className="text-sm text-muted-foreground">No revenue data yet.</p>
-        ) : (
-          <div className="grid grid-cols-1 sm:grid-cols-2 gap-6">
-            {/* Regular */}
-            <div className="flex flex-col gap-2">
-              <div className="flex items-center justify-between mb-1">
-                <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Regular</span>
-                <span className="text-xs text-muted-foreground tabular-nums">
-                  {(stats?.totalNormalBookings ?? 0).toLocaleString()} bookings · {(stats?.totalNormalTickets ?? 0).toLocaleString()} tickets
-                </span>
-              </div>
-              {normalRows.length === 0
-                ? <p className="text-xs text-muted-foreground py-1">No revenue yet</p>
-                : normalRows.map(renderCurrencyRow)}
-              {normalRows.length > 0 && (
-                <div className="flex items-center justify-between rounded-md bg-muted/40 px-3 py-2 mt-1">
-                  <span className="text-xs font-semibold text-muted-foreground">Subtotal</span>
-                  <span className="text-sm font-bold tabular-nums">{formatCurrency(normalGrand, 'ETB')}</span>
-                </div>
-              )}
-            </div>
-
-            {/* Package */}
-            <div className="flex flex-col gap-2">
-              <div className="flex items-center justify-between mb-1">
-                <span className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">Package</span>
-                <span className="text-xs text-muted-foreground tabular-nums">
-                  {(stats?.totalPackageBookings ?? 0).toLocaleString()} bookings · {(stats?.totalPackageTickets ?? 0).toLocaleString()} tickets
-                </span>
-              </div>
-              {packageRows.length === 0
-                ? <p className="text-xs text-muted-foreground py-1">No revenue yet</p>
-                : packageRows.map(renderCurrencyRow)}
-              {packageRows.length > 0 && (
-                <div className="flex items-center justify-between rounded-md bg-muted/40 px-3 py-2 mt-1">
-                  <span className="text-xs font-semibold text-muted-foreground">Subtotal</span>
-                  <span className="text-sm font-bold tabular-nums">{formatCurrency(packageGrand, 'ETB')}</span>
-                </div>
-              )}
-            </div>
-          </div>
-        )}
-        {!statsLoading && (normalRows.length > 0 || packageRows.length > 0) && (
-          <div className="flex items-center justify-between rounded-lg border border-border bg-muted/30 px-4 py-3 mt-4">
-            <span className="text-sm font-semibold text-muted-foreground">Grand Total (ETB equivalent)</span>
-            <span className="text-lg font-bold text-emerald-600 dark:text-emerald-400 tabular-nums">
-              {formatCurrency(overallGrand, 'ETB')}
-            </span>
-          </div>
-        )}
-      </div>
-
-      {/* Charts */}
-      <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
-        {/* Revenue Trend */}
-        <div className="card">
-          <h3 className="text-base font-semibold mb-4">
-            Revenue Trend{' '}
-            <span className="text-xs font-normal text-muted-foreground">(confirmed, ETB)</span>
-          </h3>
-          {chartData.length > 0 ? (
-            <ResponsiveContainer width="100%" height={280}>
-              <LineChart data={chartData}>
-                <CartesianGrid strokeDasharray="3 3" stroke="#e5e7eb" />
-                <XAxis dataKey="date" tick={{ fontSize: 11 }} />
-                <YAxis tick={{ fontSize: 11 }} />
-                <Tooltip formatter={(value: number) => [`ETB ${Math.round(value).toLocaleString()}`, 'Revenue']} />
-                <Legend />
-                <Line type="monotone" dataKey="revenue" stroke="#10b981" dot={{ r: 4 }} activeDot={{ r: 6 }} strokeWidth={2} />
-              </LineChart>
-            </ResponsiveContainer>
-          ) : (
-            <div className="h-[280px] flex items-center justify-center text-muted-foreground text-sm">
-              No data for selected range
-            </div>
-          )}
-        </div>
-
-        {/* Daily Confirmed Bookings */}
-        <div className="card">
-          <h3 className="text-base font-semibold mb-4">Daily Confirmed Bookings</h3>
-          {chartData.length > 0 ? (
-            <ResponsiveContainer width="100%" height={280}>
-              <BarChart data={chartData}>
-                <CartesianGrid strokeDasharray="3 3" stroke="#e5e7eb" />
-                <XAxis dataKey="date" tick={{ fontSize: 11 }} />
-                <YAxis tick={{ fontSize: 11 }} />
-                <Tooltip />
-                <Bar dataKey="bookings" fill="#3b82f6" radius={[3, 3, 0, 0]} />
-              </BarChart>
-            </ResponsiveContainer>
-          ) : (
-            <div className="h-[280px] flex items-center justify-center text-muted-foreground text-sm">
-              No data for selected range
-            </div>
-          )}
-        </div>
-
-        {/* Booking Status Distribution */}
-        <div className="card">
-          <h3 className="text-base font-semibold mb-4">Booking Status Distribution</h3>
-          {bookings.length > 0 ? (
-            <ResponsiveContainer width="100%" height={280}>
-              <PieChart>
-                <Pie
-                  data={[
-                    { name: 'Confirmed', value: bookings.filter((b: any) => b.status === 'CONFIRMED').length },
-                    { name: 'Boarded', value: bookings.filter((b: any) => b.status === 'BOARDED').length },
-                    { name: 'Cancelled', value: bookings.filter((b: any) => b.status === 'CANCELLED').length },
-                    { name: 'Other', value: bookings.filter((b: any) => !['CONFIRMED', 'BOARDED', 'CANCELLED'].includes(b.status)).length },
-                  ].filter(d => d.value > 0)}
-                  cx="50%" cy="50%"
-                  labelLine={false}
-                  label={({ name, value }) => `${name}: ${value}`}
-                  outerRadius={100}
-                  dataKey="value"
-                >
-                  {STATUS_COLORS.map((color, idx) => <Cell key={idx} fill={color} />)}
-                </Pie>
-                <Tooltip />
-              </PieChart>
-            </ResponsiveContainer>
-          ) : (
-            <div className="h-[280px] flex items-center justify-center text-muted-foreground text-sm">
-              No data for selected range
-            </div>
-          )}
-        </div>
-
-        {/* Payment Methods */}
-        <div className="card">
-          <h3 className="text-base font-semibold mb-4">Payment Methods</h3>
-          {bookings.length > 0 ? (
-            <div className="space-y-3 pt-1">
-              {(Object.entries(
-                bookings.reduce((acc: Record<string, number>, b: any) => {
-                  const method = b.paymentIntent?.method || 'Unknown';
-                  acc[method] = (acc[method] || 0) + 1;
-                  return acc;
-                }, {} as Record<string, number>)
-              ) as [string, number][])
-                .sort(([, a], [, b]) => b - a)
-                .slice(0, 6)
-                .map(([method, count]) => {
-                  const pct = bookings.length > 0 ? Math.round((count / bookings.length) * 100) : 0;
-                  return (
-                    <div key={method} className="flex items-center gap-3">
-                      <span className="text-sm w-32 shrink-0 capitalize">{method.toLowerCase().replace(/_/g, ' ')}</span>
-                      <div className="flex-1 bg-muted rounded-full h-2">
-                        <div className="bg-primary h-2 rounded-full" style={{ width: `${pct}%` }} />
-                      </div>
-                      <span className="text-sm font-semibold tabular-nums w-8 text-right">{count}</span>
-                    </div>
-                  );
-                })}
-            </div>
-          ) : (
-            <div className="h-[280px] flex items-center justify-center text-muted-foreground text-sm">
-              No data for selected range
-            </div>
-          )}
-        </div>
-      </div>
-
-      {/* Summary */}
-      <div className="card">
-        <h3 className="text-base font-semibold mb-4">Summary</h3>
-        <div className="grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-6 gap-3">
-          {[
-            { label: 'Active Days', value: chartData.length, fromStats: false },
-            { label: 'Confirmed', value: bookings.filter((b: any) => b.status === 'CONFIRMED').length, fromStats: false },
-            { label: 'Boarded', value: bookings.filter((b: any) => b.status === 'BOARDED').length, fromStats: false },
-            { label: 'Cancelled', value: bookings.filter((b: any) => b.status === 'CANCELLED').length, fromStats: false },
-            { label: 'Regular Bookings', value: stats?.totalNormalBookings ?? 0, fromStats: true },
-            { label: 'Package Bookings', value: stats?.totalPackageBookings ?? 0, fromStats: true },
-          ].map(({ label, value, fromStats }) => (
-            <div key={label} className="border border-border rounded-lg p-3 text-center">
-              <p className="text-xs text-muted-foreground">{label}</p>
-              <p className="text-xl font-bold mt-1 tabular-nums">
-                {fromStats && statsLoading ? '—' : value.toLocaleString()}
-              </p>
-            </div>
-          ))}
-        </div>
-      </div>
-
-      {/* Export Modal */}
-      <Modal isOpen={exportModalOpen} onClose={() => setExportModalOpen(false)} title="Export Revenue Report" size="sm">
-        <div className="space-y-4">
-          <p className="text-sm text-muted-foreground">
-            Exports daily confirmed-booking revenue for the selected date range. Cancelled and refunded bookings are excluded.
-          </p>
-          <div>
-            <p className="text-sm font-medium mb-2">Format</p>
-            <div className="flex gap-3">
-              {(['csv', 'excel', 'pdf'] as const).map(fmt => (
-                <label key={fmt} className="flex items-center gap-2 cursor-pointer">
-                  <input type="radio" name="reportExportFormat" value={fmt} checked={exportFormat === fmt} onChange={() => setExportFormat(fmt)} className="w-4 h-4" />
-                  <span className="text-sm font-medium">{fmt === 'excel' ? 'Excel (.xls)' : fmt === 'pdf' ? 'PDF (Print)' : 'CSV'}</span>
-                </label>
-              ))}
-            </div>
-          </div>
-          <div className="flex justify-end gap-2 pt-4 border-t">
-            <ActionButton variant="secondary" onClick={() => setExportModalOpen(false)}>Cancel</ActionButton>
-            <ActionButton onClick={doExport}>Export</ActionButton>
-          </div>
-        </div>
-      </Modal>
-    </div>
-  );
+  redirect('/reports/overall');
 }
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/passengers/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/passengers/page.tsx
index 8ff54da6a..558526b30 100644
--- a/apps/edr-passenger-web/backoffice/src/app/reports/passengers/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/passengers/page.tsx
@@ -1,307 +1,604 @@
-'use client';
+"use client";
 
-import { useState } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { Users, Armchair, TrendingUp, Train, Download } from 'lucide-react';
-import { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer, Cell } from 'recharts';
-import { apiClient } from '@/lib/api-client';
-import { formatDateTime } from '@/lib/utils';
-import ActionButton from '@/components/ui/ActionButton';
+import { useState } from "react";
+import { useQuery } from "@tanstack/react-query";
+import { Users, Armchair, BarChart3, Train, Download } from "lucide-react";
+import { apiClient } from "@/lib/api-client";
+import { formatDateTime } from "@/lib/utils";
+import ActionButton from "@/components/ui/ActionButton";
 
-const COLORS = ['#10b981', '#3b82f6', '#f59e0b', '#8b5cf6', '#ef4444', '#06b6d4'];
-
-function StatCard({ label, value, sub, icon: Icon, color }: { label: string; value: string | number; sub?: string; icon: any; color: string }) {
-  return (
-    <div className="card flex flex-col gap-1">
-      <div className="flex items-center justify-between">
-        <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">{label}</p>
-        <div className={`rounded-lg p-1.5 ${color}`}><Icon className="h-4 w-4" /></div>
-      </div>
-      <p className="text-2xl font-bold tabular-nums mt-1">{value}</p>
-      {sub && <p className="text-xs text-muted-foreground">{sub}</p>}
-    </div>
-  );
+interface ScheduleOption {
+  id: string;
+  label: string;
 }
 
+interface PassengersReport {
+  schedule: {
+    id: string;
+    trainName: string;
+    origin: string;
+    destination: string;
+    departureAt: string;
+    arrivalAt: string;
+  };
+  summary: {
+    totalSeats: number;
+    totalPassengers: number;
+    occupancyRate: number;
+  };
+  byCoach: {
+    coachNumber: string;
+    coachType: string;
+    totalSeats: number;
+    booked: number;
+    occupancyRate: number;
+  }[];
+  byClass: {
+    className: string;
+    totalSeats: number;
+    booked: number;
+    occupancyRate: number;
+  }[];
+  byOrigin: { stationName: string; passengers: number }[];
+  byDestination: { stationName: string; passengers: number }[];
+}
+
+interface PassengerRow {
+  bookingRef: string;
+  passengerName: string;
+  passengerCategory: string;
+  idDocumentType: string | null;
+  idDocumentNumber: string | null;
+  passportNumber: string | null;
+  passportCountry: string | null;
+  seatLabel: string | null;
+  seatNumber: string | null;
+  seatClassName: string | null;
+  coachNumber: string | null;
+  coachType: string | null;
+  nationality: string | null;
+  origin: string | null;
+  destination: string | null;
+  amountPaidMinor: number;
+  currency: string;
+  isGroupBooking: boolean;
+  bookingStatus: string;
+}
+
+type Tab = "occupancy" | "list";
+
 export default function PassengersReportPage() {
-  const [scheduleId, setScheduleId] = useState('');
+  const [scheduleId, setScheduleId] = useState("");
+  const [tab, setTab] = useState<Tab>("occupancy");
+  const [listSearch, setListSearch] = useState("");
+  const [filterCoach, setFilterCoach] = useState("");
+  const [filterOrigin, setFilterOrigin] = useState("");
 
-  const { data: schedules = [] } = useQuery<any[]>({
-    queryKey: ['schedules-list'],
-    queryFn: () => apiClient.get('/schedules'),
-    select: (d: any) => d?.items ?? (Array.isArray(d) ? d : []),
+  const { data: schedulesRaw, isLoading: loadingSchedules } = useQuery<
+    ScheduleOption[]
+  >({
+    queryKey: ["report-schedules"],
+    queryFn: () => apiClient.get("/reports/schedules"),
   });
+  const schedules = schedulesRaw ?? [];
 
-  const { data, isFetching } = useQuery({
-    queryKey: ['occupancy-report', scheduleId],
-    queryFn: () => apiClient.get(`/reports/passengers?scheduleId=${scheduleId}`),
+  const { data, isLoading, isError } = useQuery<PassengersReport>({
+    queryKey: ["passengers-report", scheduleId],
+    queryFn: () =>
+      apiClient.get(`/reports/passengers?scheduleId=${scheduleId}`),
     enabled: !!scheduleId,
   });
 
-  const report = data as any;
+  const { data: passengerList = [], isLoading: listLoading } = useQuery<
+    PassengerRow[]
+  >({
+    queryKey: ["passengers-list", scheduleId],
+    queryFn: () =>
+      apiClient.get(`/reports/passengers/list?scheduleId=${scheduleId}`),
+    enabled: !!scheduleId,
+  });
 
-  const doExport = () => {
-    if (!report) return;
-    const rows = [
-      ['Coach', 'Type', 'Total Seats', 'Booked', 'Occupancy %'],
-      ...report.byCoach.map((c: any) => [c.coachNumber, c.coachType, c.totalSeats, c.booked, c.occupancyRate]),
-    ];
-    const csv = rows.map(r => r.map((v: any) => `"${v}"`).join(',')).join('\n');
-    const blob = new Blob([csv], { type: 'text/csv' });
+  const coachOptions = [
+    ...new Set(passengerList.map((p) => p.coachNumber).filter(Boolean)),
+  ].sort() as string[];
+  const originOptions = [
+    ...new Set(passengerList.map((p) => p.origin).filter(Boolean)),
+  ].sort() as string[];
+
+  const filteredList = passengerList
+    .filter((p) => {
+      if (filterCoach && p.coachNumber !== filterCoach) return false;
+      if (filterOrigin && p.origin !== filterOrigin) return false;
+      if (filterSeatClass && p.seatClassName !== filterSeatClass) return false;
+      if (listSearch.trim()) {
+        const q = listSearch.toLowerCase();
+        return (
+          p.passengerName.toLowerCase().includes(q) ||
+          p.bookingRef.toLowerCase().includes(q) ||
+          (p.idDocumentNumber ?? "").toLowerCase().includes(q) ||
+          (p.passportNumber ?? "").toLowerCase().includes(q)
+        );
+      }
+      return true;
+    })
+    .sort((a, b) => a.bookingRef.localeCompare(b.bookingRef));
+
+  const downloadCsv = (csv: string, filename: string) => {
+    const blob = new Blob([csv], { type: "text/csv" });
     const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
+    const a = document.createElement("a");
     a.href = url;
-    a.download = `occupancy-${scheduleId}-${new Date().toISOString().split('T')[0]}.csv`;
+    a.download = filename;
     a.click();
     URL.revokeObjectURL(url);
   };
 
+  const doExportOccupancy = () => {
+    if (!data) return;
+    const rows = data.byCoach.map((c) => [
+      c.coachNumber,
+      c.coachType,
+      String(c.totalSeats),
+      String(c.booked),
+      `${c.occupancyRate}%`,
+    ]);
+    downloadCsv(
+      [
+        ["Coach", "Type", "Total Seats", "Booked", "Occupancy"].join(","),
+        ...rows.map((r) => r.join(",")),
+      ].join("\n"),
+      `occupancy-${scheduleId}.csv`,
+    );
+  };
+
+  const doExportList = () => {
+    if (!passengerList.length) return;
+    const headers = [
+      "#",
+      "Name",
+      "Coach·Seat",
+      "Origin",
+      "Destination",
+      "Date",
+      "Booking Ref",
+    ];
+    const rows = passengerList.map((p, i) =>
+      [
+        String(i + 1),
+        p.passengerName,
+        p.coachSeat,
+        p.origin,
+        p.destination,
+        p.departureAt ? formatDateTime(p.departureAt) : "—",
+        p.bookingRef,
+      ].map((v) => `"${String(v).replace(/"/g, '""')}"`),
+    );
+    downloadCsv(
+      [headers.join(","), ...rows.map((r) => r.join(","))].join("\n"),
+      `passengers-${scheduleId}.csv`,
+    );
+  };
+
   return (
     <div className="space-y-6">
       <div>
-        <h1 className="text-3xl font-bold text-foreground">Passengers Report</h1>
-        <p className="text-muted-foreground mt-1">Select a schedule to view passenger occupancy breakdown</p>
+        <h1 className="text-3xl font-bold text-foreground">
+          Passengers Report
+        </h1>
+        <p className="text-muted-foreground mt-1">
+          Occupancy and passenger breakdown for a schedule
+        </p>
       </div>
 
-      {/* Schedule Selector */}
+      {/* Schedule selector */}
       <div className="card">
-        <div className="flex flex-wrap items-end gap-4">
-          <div className="flex-1 min-w-64">
+        <div className="flex items-end gap-4 flex-wrap">
+          <div className="flex-1 min-w-72">
             <label className="label">Schedule</label>
             <select
               className="input"
               value={scheduleId}
-              onChange={(e) => setScheduleId(e.target.value)}
+              onChange={(e) => {
+                setScheduleId(e.target.value);
+                setTab("occupancy");
+                setListSearch("");
+                setFilterCoach("");
+                setFilterOrigin("");
+              }}
+              disabled={loadingSchedules}
             >
-              <option value="">— Select a schedule —</option>
-              {schedules.map((s: any) => (
+              <option value="">
+                {loadingSchedules ? "Loading schedules…" : "Select a schedule…"}
+              </option>
+              {schedules.map((s) => (
                 <option key={s.id} value={s.id}>
-                  {s.train?.name ?? s.train?.number ?? 'Train'} · {s.originStation?.name} → {s.destinationStation?.name} · {s.departureAt ? new Date(s.departureAt).toLocaleString() : ''}
+                  {s.label}
                 </option>
               ))}
             </select>
           </div>
-          {isFetching && <p className="text-sm text-muted-foreground self-center">Loading…</p>}
-          {report && (
-            <ActionButton icon={Download} variant="secondary" onClick={doExport}>
+          {data && tab === "occupancy" && (
+            <ActionButton
+              icon={Download}
+              variant="secondary"
+              onClick={doExportOccupancy}
+            >
               Export CSV
             </ActionButton>
           )}
         </div>
+        {(isLoading || listLoading) && (
+          <p className="text-xs text-muted-foreground mt-2">Loading…</p>
+        )}
+        {isError && (
+          <p className="text-xs text-red-500 mt-2">Failed to load report.</p>
+        )}
       </div>
 
-      {isFetching && (
-        <div className="card py-12 text-center text-muted-foreground">Loading passengers data…</div>
-      )}
-
-      {report && (
+      {data && (
         <>
-          {/* Schedule Info */}
+          {/* Schedule info */}
           <div className="card flex items-center gap-4">
             <div className="rounded-lg bg-emerald-100 dark:bg-emerald-900/30 p-2.5">
               <Train className="h-5 w-5 text-emerald-600 dark:text-emerald-400" />
             </div>
             <div>
-              <p className="font-semibold">{report.schedule.trainName}</p>
+              <p className="font-semibold">{data.schedule.trainName}</p>
               <p className="text-sm text-muted-foreground">
-                {report.schedule.origin} → {report.schedule.destination} · Departure: {formatDateTime(report.schedule.departureAt)}
+                {data.schedule.origin} → {data.schedule.destination} ·
+                Departure: {formatDateTime(data.schedule.departureAt)}
               </p>
             </div>
           </div>
 
-          {/* Summary Cards */}
-          <div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
-            <StatCard
-              label="Total Seats"
-              value={report.summary.totalSeats}
-              icon={Armchair}
-              color="bg-blue-100 dark:bg-blue-900/30 text-blue-600 dark:text-blue-400"
-            />
-            <StatCard
-              label="Total Passengers"
-              value={report.summary.totalPassengers}
-              icon={Users}
-              color="bg-emerald-100 dark:bg-emerald-900/30 text-emerald-600 dark:text-emerald-400"
-            />
-            <StatCard
-              label="Occupancy Rate"
-              value={`${report.summary.occupancyRate}%`}
-              sub={`${report.summary.totalSeats - report.summary.totalPassengers} seats available`}
-              icon={TrendingUp}
-              color="bg-amber-100 dark:bg-amber-900/30 text-amber-600 dark:text-amber-400"
-            />
+          {/* Tabs */}
+          <div className="border-b border-border flex">
+            <button
+              onClick={() => setTab("occupancy")}
+              className={`px-5 py-2.5 text-sm font-medium border-b-2 transition-colors ${tab === "occupancy" ? "border-emerald-500 text-emerald-600 dark:text-emerald-400" : "border-transparent text-muted-foreground hover:text-foreground"}`}
+            >
+              Occupancy
+            </button>
+            <button
+              onClick={() => setTab("list")}
+              className={`px-5 py-2.5 text-sm font-medium border-b-2 transition-colors ${tab === "list" ? "border-emerald-500 text-emerald-600 dark:text-emerald-400" : "border-transparent text-muted-foreground hover:text-foreground"}`}
+            >
+              Passenger List
+              {passengerList.length > 0 ? ` (${passengerList.length})` : ""}
+            </button>
           </div>
 
-          <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
-            {/* By Coach */}
-            <div className="card">
-              <h3 className="text-base font-semibold mb-4">Occupancy by Coach</h3>
-              {report.byCoach.length > 0 ? (
-                <>
-                  <ResponsiveContainer width="100%" height={220}>
-                    <BarChart data={report.byCoach} layout="vertical" margin={{ left: 8 }}>
-                      <CartesianGrid strokeDasharray="3 3" horizontal={false} />
-                      <XAxis type="number" domain={[0, 100]} tickFormatter={(v) => `${v}%`} tick={{ fontSize: 11 }} />
-                      <YAxis type="category" dataKey="coachNumber" tick={{ fontSize: 11 }} width={56} tickFormatter={(v) => `Coach ${v}`} />
-                      <Tooltip formatter={(v: number) => [`${v}%`, 'Occupancy']} />
-                      <Bar dataKey="occupancyRate" radius={[0, 3, 3, 0]}>
-                        {report.byCoach.map((_: any, i: number) => (
-                          <Cell key={i} fill={COLORS[i % COLORS.length]} />
-                        ))}
-                      </Bar>
-                    </BarChart>
-                  </ResponsiveContainer>
-                  <table className="w-full mt-3 text-sm">
+          {/* Occupancy tab */}
+          {tab === "occupancy" && (
+            <div className="space-y-6">
+              <div className="grid grid-cols-1 sm:grid-cols-3 gap-4">
+                <div className="card flex flex-col gap-1">
+                  <div className="flex items-center justify-between">
+                    <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+                      Total Seats
+                    </p>
+                    <div className="rounded-lg bg-blue-100 dark:bg-blue-900/30 p-1.5">
+                      <Armchair className="h-4 w-4 text-blue-600 dark:text-blue-400" />
+                    </div>
+                  </div>
+                  <p className="text-2xl font-bold tabular-nums mt-1">
+                    {data.summary.totalSeats}
+                  </p>
+                </div>
+                <div className="card flex flex-col gap-1">
+                  <div className="flex items-center justify-between">
+                    <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+                      Passengers
+                    </p>
+                    <div className="rounded-lg bg-emerald-100 dark:bg-emerald-900/30 p-1.5">
+                      <Users className="h-4 w-4 text-emerald-600 dark:text-emerald-400" />
+                    </div>
+                  </div>
+                  <p className="text-2xl font-bold tabular-nums mt-1">
+                    {data.summary.totalPassengers}
+                  </p>
+                </div>
+                <div className="card flex flex-col gap-1">
+                  <div className="flex items-center justify-between">
+                    <p className="text-xs font-semibold uppercase tracking-wider text-muted-foreground">
+                      Occupancy Rate
+                    </p>
+                    <div className="rounded-lg bg-purple-100 dark:bg-purple-900/30 p-1.5">
+                      <BarChart3 className="h-4 w-4 text-purple-600 dark:text-purple-400" />
+                    </div>
+                  </div>
+                  <p className="text-2xl font-bold tabular-nums mt-1">
+                    {data.summary.occupancyRate}%
+                  </p>
+                  <div className="w-full bg-muted rounded-full h-1.5 mt-1">
+                    <div
+                      className="bg-purple-500 h-1.5 rounded-full"
+                      style={{ width: `${data.summary.occupancyRate}%` }}
+                    />
+                  </div>
+                </div>
+              </div>
+
+              <div className="card">
+                <h3 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground mb-4">
+                  By Coach
+                </h3>
+                <div className="overflow-x-auto">
+                  <table className="w-full text-sm">
                     <thead>
-                      <tr className="text-xs text-muted-foreground border-b border-border">
-                        <th className="text-left py-1.5 font-medium">Coach</th>
-                        <th className="text-left py-1.5 font-medium">Type</th>
-                        <th className="text-right py-1.5 font-medium">Booked</th>
-                        <th className="text-right py-1.5 font-medium">Total</th>
-                        <th className="text-right py-1.5 font-medium">Rate</th>
+                      <tr className="border-b border-border text-left text-xs text-muted-foreground uppercase tracking-wider">
+                        <th className="pb-2 pr-4">Coach</th>
+                        <th className="pb-2 pr-4">Type</th>
+                        <th className="pb-2 pr-4 text-right">Seats</th>
+                        <th className="pb-2 pr-4 text-right">Booked</th>
+                        <th className="pb-2">Occupancy</th>
                       </tr>
                     </thead>
-                    <tbody>
-                      {report.byCoach.map((c: any, i: number) => (
-                        <tr key={i} className="border-b border-border/50 last:border-0">
-                          <td className="py-1.5 font-mono font-semibold">Coach {c.coachNumber}</td>
-                          <td className="py-1.5 text-muted-foreground">{c.coachType}</td>
-                          <td className="py-1.5 text-right tabular-nums">{c.booked}</td>
-                          <td className="py-1.5 text-right tabular-nums text-muted-foreground">{c.totalSeats}</td>
-                          <td className="py-1.5 text-right tabular-nums font-semibold">{c.occupancyRate}%</td>
+                    <tbody className="divide-y divide-border">
+                      {data.byCoach.map((c) => (
+                        <tr key={c.coachNumber} className="hover:bg-muted/30">
+                          <td className="py-2 pr-4 font-semibold">
+                            {c.coachNumber}
+                          </td>
+                          <td className="py-2 pr-4 text-muted-foreground">
+                            {c.coachType}
+                          </td>
+                          <td className="py-2 pr-4 text-right tabular-nums">
+                            {c.totalSeats}
+                          </td>
+                          <td className="py-2 pr-4 text-right tabular-nums">
+                            {c.booked}
+                          </td>
+                          <td className="py-2">
+                            <div className="flex items-center gap-2">
+                              <div className="flex-1 bg-muted rounded-full h-1.5">
+                                <div
+                                  className="bg-emerald-500 h-1.5 rounded-full"
+                                  style={{ width: `${c.occupancyRate}%` }}
+                                />
+                              </div>
+                              <span className="tabular-nums text-xs w-10 text-right">
+                                {c.occupancyRate}%
+                              </span>
+                            </div>
+                          </td>
                         </tr>
                       ))}
                     </tbody>
                   </table>
-                </>
-              ) : (
-                <p className="text-sm text-muted-foreground">No coach data</p>
-              )}
-            </div>
+                </div>
+              </div>
 
-            {/* By Class */}
-            <div className="card">
-              <h3 className="text-base font-semibold mb-4">Occupancy by Class</h3>
-              {report.byClass.length > 0 ? (
-                <>
-                  <ResponsiveContainer width="100%" height={220}>
-                    <BarChart data={report.byClass}>
-                      <CartesianGrid strokeDasharray="3 3" />
-                      <XAxis dataKey="className" tick={{ fontSize: 11 }} />
-                      <YAxis domain={[0, 100]} tickFormatter={(v) => `${v}%`} tick={{ fontSize: 11 }} />
-                      <Tooltip formatter={(v: number) => [`${v}%`, 'Occupancy']} />
-                      <Bar dataKey="occupancyRate" radius={[3, 3, 0, 0]}>
-                        {report.byClass.map((_: any, i: number) => (
-                          <Cell key={i} fill={COLORS[i % COLORS.length]} />
-                        ))}
-                      </Bar>
-                    </BarChart>
-                  </ResponsiveContainer>
-                  <table className="w-full mt-3 text-sm">
-                    <thead>
-                      <tr className="text-xs text-muted-foreground border-b border-border">
-                        <th className="text-left py-1.5 font-medium">Class</th>
-                        <th className="text-right py-1.5 font-medium">Booked</th>
-                        <th className="text-right py-1.5 font-medium">Total</th>
-                        <th className="text-right py-1.5 font-medium">Rate</th>
+              <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
+                <div className="card">
+                  <h3 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground mb-4">
+                    By Class
+                  </h3>
+                  <div className="space-y-3">
+                    {data.byClass.map((c) => (
+                      <div key={c.className}>
+                        <div className="flex justify-between text-sm mb-1">
+                          <span className="font-medium">{c.className}</span>
+                          <span className="tabular-nums text-muted-foreground">
+                            {c.booked}/{c.totalSeats}
+                          </span>
+                        </div>
+                        <div className="flex items-center gap-2">
+                          <div className="flex-1 bg-muted rounded-full h-1.5">
+                            <div
+                              className="bg-blue-500 h-1.5 rounded-full"
+                              style={{ width: `${c.occupancyRate}%` }}
+                            />
+                          </div>
+                          <span className="text-xs tabular-nums w-10 text-right">
+                            {c.occupancyRate}%
+                          </span>
+                        </div>
+                      </div>
+                    ))}
+                  </div>
+                </div>
+                <div className="card">
+                  <h3 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground mb-4">
+                    By Boarding Station
+                  </h3>
+                  <div className="space-y-2">
+                    {data.byOrigin.map((o) => (
+                      <div
+                        key={o.stationName}
+                        className="flex justify-between text-sm"
+                      >
+                        <span className="text-muted-foreground truncate">
+                          {o.stationName}
+                        </span>
+                        <span className="font-semibold tabular-nums ml-2">
+                          {o.passengers}
+                        </span>
+                      </div>
+                    ))}
+                    {data.byOrigin.length === 0 && (
+                      <p className="text-xs text-muted-foreground">No data</p>
+                    )}
+                  </div>
+                </div>
+                <div className="card">
+                  <h3 className="text-sm font-semibold uppercase tracking-wider text-muted-foreground mb-4">
+                    By Alighting Station
+                  </h3>
+                  <div className="space-y-2">
+                    {data.byDestination.map((d) => (
+                      <div
+                        key={d.stationName}
+                        className="flex justify-between text-sm"
+                      >
+                        <span className="text-muted-foreground truncate">
+                          {d.stationName}
+                        </span>
+                        <span className="font-semibold tabular-nums ml-2">
+                          {d.passengers}
+                        </span>
+                      </div>
+                    ))}
+                    {data.byDestination.length === 0 && (
+                      <p className="text-xs text-muted-foreground">No data</p>
+                    )}
+                  </div>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Passenger List tab */}
+          {tab === "list" && (
+            <div className="space-y-4">
+              <div className="flex items-center gap-3 flex-wrap">
+                <input
+                  type="text"
+                  className="input max-w-sm flex-1"
+                  placeholder="Search by name or booking ref…"
+                  value={listSearch}
+                  onChange={(e) => setListSearch(e.target.value)}
+                />
+                <select
+                  className="input w-40"
+                  value={filterSeatClass}
+                  onChange={(e) => setFilterSeatClass(e.target.value)}
+                >
+                  <option value="">All classes</option>
+                  {seatClassOptions.map((c) => (
+                    <option key={c} value={c}>
+                      {c}
+                    </option>
+                  ))}
+                </select>
+                <select
+                  className="input w-36"
+                  value={filterOrigin}
+                  onChange={(e) => setFilterOrigin(e.target.value)}
+                >
+                  <option value="">All origins</option>
+                  {originOptions.map((o) => (
+                    <option key={o} value={o}>
+                      {o}
+                    </option>
+                  ))}
+                </select>
+                {passengerList.length > 0 && (
+                  <ActionButton
+                    icon={Download}
+                    variant="secondary"
+                    onClick={doExportList}
+                  >
+                    Export CSV
+                  </ActionButton>
+                )}
+              </div>
+              <div className="overflow-x-auto">
+                <table className="w-full text-sm">
+                  <thead>
+                    <tr className="border-b border-border text-left text-xs text-muted-foreground uppercase tracking-wider">
+                      <th className="pb-2 pr-4">Name</th>
+                      <th className="pb-2 pr-4">Nationality</th>
+                      <th className="pb-2 pr-4">Passport</th>
+                      <th className="pb-2 pr-4">Coach</th>
+                      <th className="pb-2 pr-4">Seat</th>
+                      <th className="pb-2 pr-4">Class</th>
+                      <th className="pb-2 pr-4">Origin</th>
+                      <th className="pb-2 pr-4">Destination</th>
+                      <th className="pb-2 pr-4">Amount Paid</th>
+                      <th className="pb-2">Booking Ref</th>
+                    </tr>
+                  </thead>
+                  <tbody className="divide-y divide-border">
+                    {filteredList.map((p, i) => (
+                      <tr
+                        key={`${p.bookingRef}-${i}`}
+                        className="hover:bg-muted/30"
+                      >
+                        <td className="py-2 pr-4 font-medium">
+                          {p.passengerName}
+                        </td>
+                        <td className="py-2 pr-4 text-xs">
+                          {p.passportNumber ? (
+                            <>
+                              <span className="text-muted-foreground">
+                                {p.passportCountry ?? "Intl"}
+                              </span>
+                              <span className="ml-1 font-mono">
+                                {p.passportNumber}
+                              </span>
+                            </>
+                          ) : (
+                            <span className="text-muted-foreground">
+                              {p.idDocumentNumber ?? "—"}
+                            </span>
+                          )}
+                        </td>
+                        <td className="py-2 pr-4 font-mono text-xs">
+                          {p.coachNumber && p.seatLabel ? (
+                            <>
+                              {p.coachNumber} · {p.seatLabel}
+                              {p.coachType && (
+                                <span className="font-sans text-muted-foreground ml-1">
+                                  ({p.coachType})
+                                </span>
+                              )}
+                            </>
+                          ) : (
+                            (p.coachNumber ?? p.seatLabel ?? "—")
+                          )}
+                        </td>
+                        <td className="py-2 pr-4 text-muted-foreground text-xs">
+                          {p.origin && p.destination
+                            ? `${p.origin} → ${p.destination}`
+                            : (p.origin ?? p.destination ?? "—")}
+                        </td>
+                        <td className="py-2 pr-4 text-xs">
+                          <div className="flex items-center gap-1.5">
+                            <span className="tabular-nums font-medium">
+                              {(p.amountPaidMinor / 100).toLocaleString(
+                                "en-US",
+                                {
+                                  minimumFractionDigits: 2,
+                                  maximumFractionDigits: 2,
+                                },
+                              )}{" "}
+                              {p.currency}
+                            </span>
+                            {p.isGroupBooking && (
+                              <span className="inline-flex items-center rounded px-1.5 py-0.5 text-[10px] font-semibold bg-blue-100 text-blue-700 dark:bg-blue-900/40 dark:text-blue-300">
+                                Group
+                              </span>
+                            )}
+                          </div>
+                        </td>
+                        <td className="py-2 font-mono text-xs">
+                          {p.bookingRef}
+                        </td>
                       </tr>
-                    </thead>
-                    <tbody>
-                      {report.byClass.map((c: any, i: number) => (
-                        <tr key={i} className="border-b border-border/50 last:border-0">
-                          <td className="py-1.5 font-medium">{c.className}</td>
-                          <td className="py-1.5 text-right tabular-nums">{c.booked}</td>
-                          <td className="py-1.5 text-right tabular-nums text-muted-foreground">{c.totalSeats}</td>
-                          <td className="py-1.5 text-right tabular-nums font-semibold">{c.occupancyRate}%</td>
-                        </tr>
-                      ))}
-                    </tbody>
-                  </table>
-                </>
-              ) : (
-                <p className="text-sm text-muted-foreground">No class data</p>
-              )}
-            </div>
-
-            {/* By Origin */}
-            <div className="card">
-              <h3 className="text-base font-semibold mb-4">Passengers by Boarding Station</h3>
-              {report.byOrigin.length > 0 ? (
-                <table className="w-full text-sm">
-                  <thead>
-                    <tr className="text-xs text-muted-foreground border-b border-border">
-                      <th className="text-left py-1.5 font-medium">Station</th>
-                      <th className="text-right py-1.5 font-medium">Passengers</th>
-                      <th className="text-right py-1.5 font-medium">Share</th>
-                    </tr>
-                  </thead>
-                  <tbody>
-                    {report.byOrigin.map((o: any, i: number) => {
-                      const pct = report.summary.totalPassengers > 0
-                        ? ((o.passengers / report.summary.totalPassengers) * 100).toFixed(1)
-                        : '0';
-                      return (
-                        <tr key={i} className="border-b border-border/50 last:border-0">
-                          <td className="py-2">
-                            <div className="flex items-center gap-2">
-                              <div className="w-2 h-2 rounded-full flex-shrink-0" style={{ background: COLORS[i % COLORS.length] }} />
-                              {o.stationName}
-                            </div>
-                          </td>
-                          <td className="py-2 text-right tabular-nums font-semibold">{o.passengers}</td>
-                          <td className="py-2 text-right tabular-nums text-muted-foreground">{pct}%</td>
-                        </tr>
-                      );
-                    })}
+                    ))}
+                    {filteredList.length === 0 && (
+                      <tr>
+                        <td
+                          colSpan={6}
+                          className="py-8 text-center text-sm text-muted-foreground"
+                        >
+                          No passengers found
+                        </td>
+                      </tr>
+                    )}
                   </tbody>
                 </table>
-              ) : (
-                <p className="text-sm text-muted-foreground">No boarding station data</p>
-              )}
+              </div>
             </div>
-
-            {/* By Destination */}
-            <div className="card">
-              <h3 className="text-base font-semibold mb-4">Passengers by Alighting Station</h3>
-              {report.byDestination.length > 0 ? (
-                <table className="w-full text-sm">
-                  <thead>
-                    <tr className="text-xs text-muted-foreground border-b border-border">
-                      <th className="text-left py-1.5 font-medium">Station</th>
-                      <th className="text-right py-1.5 font-medium">Passengers</th>
-                      <th className="text-right py-1.5 font-medium">Share</th>
-                    </tr>
-                  </thead>
-                  <tbody>
-                    {report.byDestination.map((d: any, i: number) => {
-                      const pct = report.summary.totalPassengers > 0
-                        ? ((d.passengers / report.summary.totalPassengers) * 100).toFixed(1)
-                        : '0';
-                      return (
-                        <tr key={i} className="border-b border-border/50 last:border-0">
-                          <td className="py-2">
-                            <div className="flex items-center gap-2">
-                              <div className="w-2 h-2 rounded-full flex-shrink-0" style={{ background: COLORS[i % COLORS.length] }} />
-                              {d.stationName}
-                            </div>
-                          </td>
-                          <td className="py-2 text-right tabular-nums font-semibold">{d.passengers}</td>
-                          <td className="py-2 text-right tabular-nums text-muted-foreground">{pct}%</td>
-                        </tr>
-                      );
-                    })}
-                  </tbody>
-                </table>
-              ) : (
-                <p className="text-sm text-muted-foreground">No alighting station data</p>
-              )}
-            </div>
-          </div>
+          )}
         </>
       )}
 
-      {!report && !isFetching && scheduleId && (
-        <div className="card py-12 text-center text-muted-foreground">No data found for this schedule.</div>
+      {!data && !isLoading && scheduleId && (
+        <div className="card py-12 text-center text-muted-foreground">
+          No data found for this schedule.
+        </div>
       )}
 
       {!scheduleId && (
diff --git a/apps/edr-passenger-web/backoffice/src/app/reports/seats/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reports/seats/page.tsx
index 08b4f2462..a31aab988 100644
--- a/apps/edr-passenger-web/backoffice/src/app/reports/seats/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/reports/seats/page.tsx
@@ -1,99 +1,134 @@
-'use client';
+"use client";
 
-import { useState, useMemo } from 'react';
-import { useQuery } from '@tanstack/react-query';
-import { Download, Armchair, CheckCircle, Clock, AlertCircle, Ban } from 'lucide-react';
-import { bookingsApi } from '@/lib/api';
-import { dashboardApi } from '@/lib/api/dashboard';
-import Badge from '@/components/ui/Badge';
-import ActionButton from '@/components/ui/ActionButton';
-import { formatDateTime, formatCurrency } from '@/lib/utils';
+import { useState, useMemo } from "react";
+import { useQuery } from "@tanstack/react-query";
+import {
+  Download,
+  Armchair,
+  CheckCircle,
+  Clock,
+  AlertCircle,
+  Ban,
+} from "lucide-react";
+import { bookingsApi, seatsApi } from "@/lib/api";
+import Badge from "@/components/ui/Badge";
+import ActionButton from "@/components/ui/ActionButton";
+import { formatDateTime, formatCurrency } from "@/lib/utils";
 
-interface SeatRow {
+interface ScheduleOption { id: string; label: string; }
+
+interface BookedSeatRow {
   bookingRef: string;
   passengerName: string;
-  seatNumber: string;
-  coachNumber: string;
+  passengerCategory: string;
+  coachNumber: string | null;
+  seatNumber: string | null;
+  seatClassName: string | null;
   fareMinor: number;
   currency: string;
-  paymentStatus: string;
   bookingStatus: string;
+  paymentStatus: string;
   bookedAt: string;
-  releaseAt: string | null;
-  scheduleOrigin: string;
-  scheduleDestination: string;
-  scheduleDeparture: string;
 }
 
-const HOLD_DURATION_MS = 5 * 60 * 1000;
+interface BlockedSeatRow {
+  id: string;
+  coachNumber: string | null;
+  seatNumber: string | null;
+  seatClassName: string | null;
+  reason: string;
+  blockedBy: string;
+  blockedAt: string;
+  unblockAt: string | null;
+}
 
 function getReleaseAt(booking: any, seat: any): string | null {
-  const paymentStatus = booking.paymentIntent?.status || 'PENDING';
-  if (paymentStatus === 'SUCCEEDED' || paymentStatus === 'COMPLETED') return null;
-  if (booking.status === 'CONFIRMED') return null;
+  const paymentStatus = booking.paymentIntent?.status || "PENDING";
+  if (paymentStatus === "SUCCEEDED" || paymentStatus === "COMPLETED")
+    return null;
+  if (booking.status === "CONFIRMED") return null;
   if (seat?.holdExpiresAt) return seat.holdExpiresAt;
   if (booking.createdAt) {
-    return new Date(new Date(booking.createdAt).getTime() + HOLD_DURATION_MS).toISOString();
+    return new Date(
+      new Date(booking.createdAt).getTime() + HOLD_DURATION_MS,
+    ).toISOString();
   }
   return null;
 }
 
-function isExpired(releaseAt: string | null): boolean {
-  if (!releaseAt) return false;
-  return new Date(releaseAt) < new Date();
+function csvEscape(v: string) { return `"${String(v).replace(/"/g, '""')}"`; }
+
+function downloadCsv(csv: string, filename: string) {
+  const blob = new Blob([csv], { type: 'text/csv' });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url; a.download = filename; a.click();
+  URL.revokeObjectURL(url);
 }
 
 export default function SeatStatusReportPage() {
-  const [statusFilter, setStatusFilter] = useState<'ALL' | 'PAID' | 'UNPAID'>('ALL');
-  const [search, setSearch] = useState('');
+  const [statusFilter, setStatusFilter] = useState<"ALL" | "PAID" | "UNPAID">(
+    "ALL",
+  );
+  const [search, setSearch] = useState("");
 
-  const { data: stats } = useQuery({
-    queryKey: ['backoffice-stats'],
-    queryFn: dashboardApi.getBackofficeStats,
-    staleTime: 30000,
+  const { data: blockedSeats = [] } = useQuery({
+    queryKey: ["blocked-seats"],
+    queryFn: () =>
+      seatsApi
+        .getBlocked()
+        .then((r: any) => (Array.isArray(r) ? r : (r?.data ?? []))),
   });
+  const schedules = schedulesRaw ?? [];
 
   const { data: bookingsData, isLoading } = useQuery({
-    queryKey: ['seat-report-bookings'],
+    queryKey: ["seat-report-bookings"],
     queryFn: () => bookingsApi.getAll({ pageSize: 1000 }),
   });
 
-  const rows: SeatRow[] = useMemo(() => {
-    const bookings: any[] = bookingsData?.items || [];
-    const result: SeatRow[] = [];
+  const bookedSeats = data?.bookedSeats ?? [];
+  const blockedSeats = data?.blockedSeats ?? [];
 
     for (const booking of bookings) {
-      if (booking.status === 'CANCELLED') continue;
+      if (booking.status === "CANCELLED") continue;
       const seats: any[] = booking.seats || [];
-      const paymentStatus = booking.paymentIntent?.status || 'PENDING';
+      const paymentStatus = booking.paymentIntent?.status || "PENDING";
 
       for (const seat of seats) {
         result.push({
-          bookingRef: booking.bookingRef || '—',
-          passengerName: seat.passengerName || seat.name || booking.passengerNames?.[0] || '—',
-          seatNumber: seat.seat?.seatNumber || seat.seatNumber || '—',
-          coachNumber: seat.seat?.coach?.number || seat.coach || '—',
+          bookingRef: booking.bookingRef || "—",
+          passengerName:
+            seat.passengerName ||
+            seat.name ||
+            booking.passengerNames?.[0] ||
+            "—",
+          seatNumber: seat.seat?.seatNumber || seat.seatNumber || "—",
+          coachNumber: seat.seat?.coach?.number || seat.coach || "—",
           fareMinor: seat.fareMinor ?? 0,
-          currency: booking.currency || 'ETB',
+          currency: booking.currency || "ETB",
           paymentStatus,
           bookingStatus: booking.status,
           bookedAt: booking.createdAt,
           releaseAt: getReleaseAt(booking, seat),
-          scheduleOrigin: booking.schedule?.originStation?.name || '—',
-          scheduleDestination: booking.schedule?.destinationStation?.name || '—',
-          scheduleDeparture: booking.schedule?.departureAt || '',
+          scheduleOrigin: booking.schedule?.originStation?.name || "—",
+          scheduleDestination:
+            booking.schedule?.destinationStation?.name || "—",
+          scheduleDeparture: booking.schedule?.departureAt || "",
         });
       }
     }
+    return true;
+  });
 
     return result;
   }, [bookingsData]);
 
   const filtered = useMemo(() => {
     return rows.filter((r) => {
-      const isPaid = r.paymentStatus === 'SUCCEEDED' || r.paymentStatus === 'COMPLETED';
-      if (statusFilter === 'PAID' && !isPaid) return false;
-      if (statusFilter === 'UNPAID' && isPaid) return false;
+      const isPaid =
+        r.paymentStatus === "SUCCEEDED" || r.paymentStatus === "COMPLETED";
+      if (statusFilter === "PAID" && !isPaid) return false;
+      if (statusFilter === "UNPAID" && isPaid) return false;
       if (search) {
         const q = search.toLowerCase();
         return (
@@ -108,17 +143,29 @@ export default function SeatStatusReportPage() {
   }, [rows, statusFilter, search]);
 
   const paidCount = rows.filter(
-    (r) => r.paymentStatus === 'SUCCEEDED' || r.paymentStatus === 'COMPLETED'
+    (r) => r.paymentStatus === "SUCCEEDED" || r.paymentStatus === "COMPLETED",
   ).length;
   const unpaidCount = rows.length - paidCount;
   const expiredCount = rows.filter((r) => isExpired(r.releaseAt)).length;
 
   const doExport = () => {
-    if (!filtered.length) { alert('No data to export'); return; }
+    if (!filtered.length) {
+      alert("No data to export");
+      return;
+    }
     const headers = [
-      'Booking Ref', 'Passenger', 'Seat', 'Coach', 'Fare',
-      'Payment Status', 'Booking Status', 'Booked At', 'Release At',
-      'Origin', 'Destination', 'Departure',
+      "Booking Ref",
+      "Passenger",
+      "Seat",
+      "Coach",
+      "Fare",
+      "Payment Status",
+      "Booking Status",
+      "Booked At",
+      "Release At",
+      "Origin",
+      "Destination",
+      "Departure",
     ];
     const csvRows = filtered.map((r) => [
       r.bookingRef,
@@ -128,21 +175,21 @@ export default function SeatStatusReportPage() {
       formatCurrency(r.fareMinor, r.currency),
       r.paymentStatus,
       r.bookingStatus,
-      r.bookedAt ? formatDateTime(r.bookedAt) : '—',
-      r.releaseAt ? formatDateTime(r.releaseAt) : '—',
+      r.bookedAt ? formatDateTime(r.bookedAt) : "—",
+      r.releaseAt ? formatDateTime(r.releaseAt) : "—",
       r.scheduleOrigin,
       r.scheduleDestination,
-      r.scheduleDeparture ? formatDateTime(r.scheduleDeparture) : '—',
+      r.scheduleDeparture ? formatDateTime(r.scheduleDeparture) : "—",
     ]);
     const csv = [
-      headers.map((h) => `"${h}"`).join(','),
-      ...csvRows.map((row) => row.map((v) => `"${v}"`).join(',')),
-    ].join('\n');
-    const blob = new Blob([csv], { type: 'text/csv' });
+      headers.map((h) => `"${h}"`).join(","),
+      ...csvRows.map((row) => row.map((v) => `"${v}"`).join(",")),
+    ].join("\n");
+    const blob = new Blob([csv], { type: "text/csv" });
     const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
+    const a = document.createElement("a");
     a.href = url;
-    a.download = `seat-status-report-${new Date().toISOString().split('T')[0]}.csv`;
+    a.download = `seat-status-report-${new Date().toISOString().split("T")[0]}.csv`;
     a.click();
     URL.revokeObjectURL(url);
   };
@@ -150,9 +197,12 @@ export default function SeatStatusReportPage() {
   return (
     <div className="space-y-6">
       <div>
-        <h1 className="text-3xl font-bold text-foreground">Seat Status Report</h1>
+        <h1 className="text-3xl font-bold text-foreground">
+          Seat Status Report
+        </h1>
         <p className="text-muted-foreground mt-1">
-          Track booked seats — paid vs unpaid, booking times, and hold release times
+          Track booked seats — paid vs unpaid, booking times, and hold release
+          times
         </p>
       </div>
 
@@ -161,24 +211,34 @@ export default function SeatStatusReportPage() {
         <div className="card">
           <div className="flex items-start justify-between">
             <div>
-              <p className="text-muted-foreground text-sm font-medium">Paid Seats</p>
+              <p className="text-muted-foreground text-sm font-medium">
+                Paid Seats
+              </p>
               <p className="text-2xl font-bold mt-2 text-green-600 dark:text-green-400">
                 {paidCount}
               </p>
-              <p className="text-xs text-muted-foreground mt-1">Payment confirmed</p>
+              <p className="text-xs text-muted-foreground mt-1">
+                Payment confirmed
+              </p>
             </div>
             <CheckCircle className="h-8 w-8 text-green-500 opacity-30" />
           </div>
         </div>
+        {isLoading && <p className="text-xs text-muted-foreground mt-2">Loading…</p>}
+      </div>
 
         <div className="card">
           <div className="flex items-start justify-between">
             <div>
-              <p className="text-muted-foreground text-sm font-medium">Unpaid Seats</p>
+              <p className="text-muted-foreground text-sm font-medium">
+                Unpaid Seats
+              </p>
               <p className="text-2xl font-bold mt-2 text-amber-600 dark:text-amber-400">
                 {unpaidCount}
               </p>
-              <p className="text-xs text-muted-foreground mt-1">Awaiting payment</p>
+              <p className="text-xs text-muted-foreground mt-1">
+                Awaiting payment
+              </p>
             </div>
             <Clock className="h-8 w-8 text-amber-500 opacity-30" />
           </div>
@@ -187,27 +247,52 @@ export default function SeatStatusReportPage() {
         <div className="card">
           <div className="flex items-start justify-between">
             <div>
-              <p className="text-muted-foreground text-sm font-medium">Expired Holds</p>
+              <p className="text-muted-foreground text-sm font-medium">
+                Expired Holds
+              </p>
               <p className="text-2xl font-bold mt-2 text-red-600 dark:text-red-400">
                 {expiredCount}
               </p>
-              <p className="text-xs text-muted-foreground mt-1">Hold time passed, not paid</p>
+              <p className="text-xs text-muted-foreground mt-1">
+                Hold time passed, not paid
+              </p>
             </div>
-            <AlertCircle className="h-8 w-8 text-red-500 opacity-30" />
           </div>
-        </div>
 
         <div className="card">
           <div className="flex items-start justify-between">
             <div>
-              <p className="text-muted-foreground text-sm font-medium">Blocked Seats</p>
-              <p className="text-2xl font-bold mt-2 text-slate-600 dark:text-slate-400">
-                {stats?.blockedSeatsCount ?? '—'}
+              <p className="text-muted-foreground text-sm font-medium">
+                Blocked Seats
+              </p>
+              <p className="text-2xl font-bold mt-2 text-slate-600 dark:text-slate-400">
+                {blockedSeats.length}
+              </p>
+              <p className="text-xs text-muted-foreground mt-1">
+                Manually blocked
               </p>
-              <p className="text-xs text-muted-foreground mt-1">Globally blocked</p>
             </div>
-            <Ban className="h-8 w-8 text-slate-500 opacity-30" />
           </div>
+          {blockedSeats.length > 0 && (
+            <div className="mt-3 border-t border-border pt-3 flex flex-col gap-1 max-h-32 overflow-y-auto">
+              {blockedSeats.map((b: any) => (
+                <div
+                  key={b.id}
+                  className="flex items-center justify-between text-xs"
+                >
+                  <span className="font-medium text-foreground">
+                    Seat {b.seatNumber} · Coach {b.coachNumber}
+                  </span>
+                  <span
+                    className="text-muted-foreground truncate max-w-24"
+                    title={b.reason}
+                  >
+                    {b.reason}
+                  </span>
+                </div>
+              ))}
+            </div>
+          )}
         </div>
       </div>
 
@@ -229,18 +314,27 @@ export default function SeatStatusReportPage() {
             <select
               className="input"
               value={statusFilter}
-              onChange={(e) => setStatusFilter(e.target.value as 'ALL' | 'PAID' | 'UNPAID')}
+              onChange={(e) =>
+                setStatusFilter(e.target.value as "ALL" | "PAID" | "UNPAID")
+              }
             >
               <option value="ALL">All Seats</option>
               <option value="PAID">Paid Only</option>
               <option value="UNPAID">Unpaid Only</option>
             </select>
           </div>
-          <ActionButton icon={Download} variant="secondary" onClick={doExport} disabled={isLoading}>
+          <ActionButton
+            icon={Download}
+            variant="secondary"
+            onClick={doExport}
+            disabled={isLoading}
+          >
             Export CSV
           </ActionButton>
         </div>
-        {isLoading && <p className="text-xs text-muted-foreground mt-2">Loading...</p>}
+        {isLoading && (
+          <p className="text-xs text-muted-foreground mt-2">Loading...</p>
+        )}
       </div>
 
       {/* Table */}
@@ -250,14 +344,14 @@ export default function SeatStatusReportPage() {
             <thead className="bg-gray-50 dark:bg-gray-800">
               <tr>
                 {[
-                  'Booking Ref',
-                  'Passenger',
-                  'Seat / Coach',
-                  'Fare',
-                  'Payment',
-                  'Booked At',
-                  'Release At',
-                  'Route',
+                  "Booking Ref",
+                  "Passenger",
+                  "Seat / Coach",
+                  "Fare",
+                  "Payment",
+                  "Booked At",
+                  "Release At",
+                  "Route",
                 ].map((h) => (
                   <th
                     key={h}
@@ -271,7 +365,8 @@ export default function SeatStatusReportPage() {
             <tbody className="bg-white dark:bg-gray-900 divide-y divide-gray-200 dark:divide-gray-700">
               {filtered.map((row, i) => {
                 const isPaid =
-                  row.paymentStatus === 'SUCCEEDED' || row.paymentStatus === 'COMPLETED';
+                  row.paymentStatus === "SUCCEEDED" ||
+                  row.paymentStatus === "COMPLETED";
                 const expired = isExpired(row.releaseAt);
                 return (
                   <tr
@@ -281,23 +376,31 @@ export default function SeatStatusReportPage() {
                     <td className="px-4 py-3 text-sm font-mono font-semibold whitespace-nowrap">
                       {row.bookingRef}
                     </td>
-                    <td className="px-4 py-3 text-sm whitespace-nowrap">{row.passengerName}</td>
+                    <td className="px-4 py-3 text-sm whitespace-nowrap">
+                      {row.passengerName}
+                    </td>
                     <td className="px-4 py-3 text-sm whitespace-nowrap">
                       <span className="font-semibold">{row.seatNumber}</span>
-                      {row.coachNumber !== '—' && (
-                        <span className="text-muted-foreground"> · Coach {row.coachNumber}</span>
+                      {row.coachNumber !== "—" && (
+                        <span className="text-muted-foreground">
+                          {" "}
+                          · Coach {row.coachNumber}
+                        </span>
                       )}
                     </td>
                     <td className="px-4 py-3 text-sm whitespace-nowrap">
                       {formatCurrency(row.fareMinor, row.currency)}
                     </td>
                     <td className="px-4 py-3 whitespace-nowrap">
-                      <Badge variant="status" status={isPaid ? 'PAID' : row.paymentStatus}>
-                        {isPaid ? 'PAID' : row.paymentStatus}
+                      <Badge
+                        variant="status"
+                        status={isPaid ? "PAID" : row.paymentStatus}
+                      >
+                        {isPaid ? "PAID" : row.paymentStatus}
                       </Badge>
                     </td>
                     <td className="px-4 py-3 text-sm whitespace-nowrap text-muted-foreground">
-                      {row.bookedAt ? formatDateTime(row.bookedAt) : '—'}
+                      {row.bookedAt ? formatDateTime(row.bookedAt) : "—"}
                     </td>
                     <td className="px-4 py-3 text-sm whitespace-nowrap">
                       {isPaid ? (
@@ -308,13 +411,13 @@ export default function SeatStatusReportPage() {
                         <span
                           className={
                             expired
-                              ? 'text-red-600 dark:text-red-400 text-xs font-semibold'
-                              : 'text-amber-600 dark:text-amber-400 text-xs font-medium'
+                              ? "text-red-600 dark:text-red-400 text-xs font-semibold"
+                              : "text-amber-600 dark:text-amber-400 text-xs font-medium"
                           }
                         >
-                          {expired ? '⚠ ' : '⏱ '}
+                          {expired ? "⚠ " : "⏱ "}
                           {formatDateTime(row.releaseAt)}
-                          {expired && ' (expired)'}
+                          {expired && " (expired)"}
                         </span>
                       ) : (
                         <span className="text-muted-foreground text-xs">—</span>
@@ -323,7 +426,9 @@ export default function SeatStatusReportPage() {
                     <td className="px-4 py-3 text-sm whitespace-nowrap text-muted-foreground">
                       {row.scheduleOrigin} → {row.scheduleDestination}
                       {row.scheduleDeparture && (
-                        <div className="text-xs">{formatDateTime(row.scheduleDeparture)}</div>
+                        <div className="text-xs">
+                          {formatDateTime(row.scheduleDeparture)}
+                        </div>
                       )}
                     </td>
                   </tr>
@@ -332,13 +437,7 @@ export default function SeatStatusReportPage() {
             </tbody>
           </table>
         </div>
-        {!isLoading && filtered.length === 0 && (
-          <div className="py-12 text-center text-muted-foreground">
-            <Armchair className="h-10 w-10 mx-auto mb-3 opacity-30" />
-            <p>No seats found</p>
-          </div>
-        )}
-      </div>
+      )}
     </div>
   );
 }
diff --git a/apps/edr-passenger-web/backoffice/src/app/routes/page.tsx b/apps/edr-passenger-web/backoffice/src/app/routes/page.tsx
index feca7e3b5..5fa655a5e 100644
--- a/apps/edr-passenger-web/backoffice/src/app/routes/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/routes/page.tsx
@@ -10,6 +10,14 @@ import Modal from '@/components/ui/Modal';
 import ConfirmDialog from '@/components/ui/ConfirmDialog';
 import { routesApi } from '@/lib/api/routes';
 import { stationsApi, fleetApi, routeCoachTemplatesApi } from '@/lib/api';
+import DateTimePicker from '@/components/ui/DateTimePicker';
+
+// EAT ↔ UTC helpers (same as schedules page)
+const EAT_MS = 3 * 60 * 60 * 1000;
+const isoToEAT = (iso: string): string =>
+  new Date(new Date(iso).getTime() + EAT_MS).toISOString().slice(0, 16);
+const eatToISO = (local: string): string =>
+  new Date(new Date(local + ':00Z').getTime() - EAT_MS).toISOString();
 
 interface RouteStop {
   stationId: string;
@@ -17,6 +25,8 @@ interface RouteStop {
   distanceKm?: number;
   distanceFromOrigin?: number;
   checkinMinutesBefore?: number;
+  plannedArrivalTime?: string;
+  plannedDepartureTime?: string;
 }
 
 type Tab = 'routes' | 'coaches';
@@ -175,6 +185,8 @@ export default function RoutesPage() {
   const [destinationDistance, setDestinationDistance] = useState<number | undefined>(undefined);
   const [originCheckinMinutes, setOriginCheckinMinutes] = useState<number | undefined>(undefined);
   const [destinationCheckinMinutes, setDestinationCheckinMinutes] = useState<number | undefined>(undefined);
+  const [originDepartureTime, setOriginDepartureTime] = useState<string>('');
+  const [destinationArrivalTime, setDestinationArrivalTime] = useState<string>('');
   const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; route: any | null; error?: string; cascade?: boolean; cascadeChecked?: boolean }>({ isOpen: false, route: null });
   const [search, setSearch] = useState('');
   const queryClient = useQueryClient();
@@ -245,18 +257,27 @@ export default function RoutesPage() {
 
     // distanceKm = cumulative distance from origin (fare engine uses destStop.distanceKm - originStop.distanceKm)
     const stopsArray = [
-      { stationId: originStationId, sequence: 1, distanceKm: 0, checkinMinutesBefore: originCheckinMinutes ?? undefined },
+      {
+        stationId: originStationId,
+        sequence: 1,
+        distanceKm: 0,
+        checkinMinutesBefore: originCheckinMinutes ?? undefined,
+        plannedDepartureTime: originDepartureTime ? eatToISO(originDepartureTime) : undefined,
+      },
       ...sortedMiddleStops.map((stop, idx) => ({
         stationId: stop.stationId,
         sequence: idx + 2,
         distanceKm: stop.distanceFromOrigin || 0,
         checkinMinutesBefore: stop.checkinMinutesBefore ?? undefined,
+        plannedArrivalTime: stop.plannedArrivalTime ? eatToISO(stop.plannedArrivalTime) : undefined,
+        plannedDepartureTime: stop.plannedDepartureTime ? eatToISO(stop.plannedDepartureTime) : undefined,
       })),
       {
         stationId: destinationStationId,
         sequence: sortedMiddleStops.length + 2,
         distanceKm: destinationDistance || 0,
         checkinMinutesBefore: destinationCheckinMinutes ?? undefined,
+        plannedArrivalTime: destinationArrivalTime ? eatToISO(destinationArrivalTime) : undefined,
       },
     ];
 
@@ -387,8 +408,10 @@ export default function RoutesPage() {
         const destStop   = routeStops[routeStops.length - 1];
         setOriginStationId(originStop.stationId);
         setOriginCheckinMinutes(originStop.checkinMinutesBefore ?? undefined);
+        setOriginDepartureTime(originStop.plannedDepartureTime ? isoToEAT(originStop.plannedDepartureTime) : '');
         setDestinationStationId(destStop.stationId);
         setDestinationCheckinMinutes(destStop.checkinMinutesBefore ?? undefined);
+        setDestinationArrivalTime(destStop.plannedArrivalTime ? isoToEAT(destStop.plannedArrivalTime) : '');
         setDestinationDistance(destStop.distanceKm || 0);
         setStops(routeStops.slice(1, -1).map((s: any) => ({
           stationId: s.stationId,
@@ -396,6 +419,8 @@ export default function RoutesPage() {
           distanceKm: s.distanceKm,
           distanceFromOrigin: s.distanceKm || 0,
           checkinMinutesBefore: s.checkinMinutesBefore ?? undefined,
+          plannedArrivalTime: s.plannedArrivalTime ? isoToEAT(s.plannedArrivalTime) : '',
+          plannedDepartureTime: s.plannedDepartureTime ? isoToEAT(s.plannedDepartureTime) : '',
         })));
       }
       setShowModal(true);
@@ -433,8 +458,10 @@ export default function RoutesPage() {
               setEditingRoute(null);
               setOriginStationId('');
               setOriginCheckinMinutes(undefined);
+              setOriginDepartureTime('');
               setDestinationStationId('');
               setDestinationCheckinMinutes(undefined);
+              setDestinationArrivalTime('');
               setDestinationDistance(undefined);
               setStops([]);
               setShowModal(true);
@@ -519,7 +546,7 @@ export default function RoutesPage() {
           setSearch('');
         }}
         title={`${editingRoute ? 'Edit' : 'Add'} Route`}
-        size="lg"
+        size="xl"
       >
         <form onSubmit={handleSubmit} className="space-y-4 max-h-[calc(100vh-200px)] overflow-y-auto">
           {editingRoute && (
@@ -665,7 +692,7 @@ export default function RoutesPage() {
           <div className="border-t pt-4">
             <div className="flex items-center justify-between mb-3">
               <label className="label mb-0">Route Stops</label>
-              <span className="text-xs text-muted-foreground">Drag to rearrange · <span className="font-medium">Cutoff min</span> overrides route check-in window per stop (leave blank to inherit)</span>
+              <span className="text-xs text-muted-foreground">Drag to rearrange · <span className="font-medium">Cutoff</span> overrides check-in · <span className="font-medium">Arr/Dep time</span> sets default times (auto-filled on schedule creation)</span>
             </div>
 
             <div className="space-y-2">
@@ -683,7 +710,7 @@ export default function RoutesPage() {
                     <span className="text-muted-foreground">Select origin station above</span>
                   )}
                 </div>
-                <div className="w-28 flex-shrink-0">
+                <div className="w-24 flex-shrink-0">
                   <input
                     type="number"
                     className="input input-sm"
@@ -694,7 +721,15 @@ export default function RoutesPage() {
                     title="Check-in cutoff override (minutes) for this stop"
                   />
                 </div>
-                <div className="text-sm text-muted-foreground w-12 text-right flex-shrink-0">0 km</div>
+                <div className="w-44 flex-shrink-0">
+                  <DateTimePicker
+                    value={originDepartureTime}
+                    onChange={setOriginDepartureTime}
+                    placeholder="Dep time"
+                    label="Planned Departure"
+                  />
+                </div>
+                <div className="text-sm text-muted-foreground w-10 text-right flex-shrink-0">0 km</div>
               </div>
 
               {stops.map((stop, index) => (
@@ -729,7 +764,7 @@ export default function RoutesPage() {
                       ))}
                     </select>
                   </div>
-                  <div className="w-28">
+                  <div className="w-20">
                     <input
                       type="number"
                       className="input input-sm"
@@ -741,17 +776,33 @@ export default function RoutesPage() {
                       required
                     />
                   </div>
-                  <div className="w-28">
+                  <div className="w-20">
                     <input
                       type="number"
                       className="input input-sm"
-                      placeholder="cutoff min"
+                      placeholder="cutoff"
                       value={stop.checkinMinutesBefore ?? ''}
                       onChange={(e) => updateStop(index, 'checkinMinutesBefore', e.target.value ? parseInt(e.target.value) : undefined)}
                       min={1}
                       title="Check-in cutoff override (minutes) for this stop"
                     />
                   </div>
+                  <div className="w-44">
+                    <DateTimePicker
+                      value={stop.plannedDepartureTime ?? ''}
+                      onChange={(v) => updateStop(index, 'plannedDepartureTime', v)}
+                      placeholder="Dep time"
+                      label="Planned Departure"
+                    />
+                  </div>
+                  <div className="w-44">
+                    <DateTimePicker
+                      value={stop.plannedArrivalTime ?? ''}
+                      onChange={(v) => updateStop(index, 'plannedArrivalTime', v)}
+                      placeholder="Arr time"
+                      label="Planned Arrival"
+                    />
+                  </div>
                   <button
                     type="button"
                     onClick={() => removeStop(index)}
@@ -790,7 +841,7 @@ export default function RoutesPage() {
                     <span className="text-muted-foreground">Select destination station above</span>
                   )}
                 </div>
-                <div className="w-28">
+                <div className="w-24">
                   {destinationStationId && (
                     <input
                       type="number"
@@ -803,7 +854,18 @@ export default function RoutesPage() {
                     />
                   )}
                 </div>
-                <div className="w-28">
+                <div className="w-44" />
+                <div className="w-44">
+                  {destinationStationId && (
+                    <DateTimePicker
+                      value={destinationArrivalTime}
+                      onChange={setDestinationArrivalTime}
+                      placeholder="Arr time"
+                      label="Planned Arrival"
+                    />
+                  )}
+                </div>
+                <div className="w-24">
                   {destinationStationId && (
                     <input
                       type="number"
diff --git a/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx b/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx
index 4ef9b97ed..9a990096b 100644
--- a/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/schedules/page.tsx
@@ -1,15 +1,133 @@
-'use client';
+"use client";
 
-import { useState, useEffect } from 'react';
-import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { Plus, Loader2, Zap, Trash2, Edit, Search, X, GripVertical } from 'lucide-react';
-import DataTable from '@/components/ui/DataTable';
-import ActionButton from '@/components/ui/ActionButton';
-import Modal from '@/components/ui/Modal';
-import ConfirmDialog from '@/components/ui/ConfirmDialog';
-import { apiClient } from '@/lib/api-client';
-import { routeCoachTemplatesApi } from '@/lib/api';
-import { formatDateTime } from '@/lib/utils';
+import { useState, useEffect } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Plus,
+  Loader2,
+  Zap,
+  Trash2,
+  Edit,
+  Search,
+  X,
+  GripVertical,
+} from "lucide-react";
+
+// ── 12-hour datetime picker ──────────────────────────────────────────────────
+interface DTPProps {
+  label: string;
+  value: string;
+  onChange: (v: string) => void;
+  required?: boolean;
+}
+
+/** value / onChange use "YYYY-MM-DDTHH:mm" (24-hr, local) — same as datetime-local */
+function DateTimePicker({ label, value, onChange, required }: DTPProps) {
+  const datePart = value.slice(0, 10);
+  const timePart = value.slice(11, 16); // HH:mm 24-hr
+
+  const hour24 = timePart ? parseInt(timePart.slice(0, 2), 10) : 12;
+  const minute = timePart ? timePart.slice(3, 5) : "00";
+  const period = hour24 >= 12 ? "PM" : "AM";
+  const hour12 = hour24 % 12 === 0 ? 12 : hour24 % 12;
+
+  const emit = (d: string, h12: number, m: string, p: string) => {
+    if (!d) return;
+    const h24 =
+      p === "AM" ? (h12 === 12 ? 0 : h12) : h12 === 12 ? 12 : h12 + 12;
+    onChange(`${d}T${String(h24).padStart(2, "0")}:${m}`);
+  };
+
+  return (
+    <div>
+      <label className="label">
+        {label}
+        {required && " *"}
+      </label>
+      <div className="flex gap-2">
+        <input
+          type="date"
+          className="input flex-1"
+          value={datePart}
+          required={required}
+          onChange={(e) => emit(e.target.value, hour12, minute, period)}
+        />
+        <select
+          className="input w-20"
+          value={hour12}
+          onChange={(e) =>
+            emit(datePart, parseInt(e.target.value, 10), minute, period)
+          }
+        >
+          {Array.from({ length: 12 }, (_, i) => i + 1).map((h) => (
+            <option key={h} value={h}>
+              {h}
+            </option>
+          ))}
+        </select>
+        <select
+          className="input w-20"
+          value={minute}
+          onChange={(e) => emit(datePart, hour12, e.target.value, period)}
+        >
+          {[
+            "00",
+            "05",
+            "10",
+            "15",
+            "20",
+            "25",
+            "30",
+            "35",
+            "40",
+            "45",
+            "50",
+            "55",
+          ].map((m) => (
+            <option key={m} value={m}>
+              {m}
+            </option>
+          ))}
+        </select>
+        <select
+          className="input w-20"
+          value={period}
+          onChange={(e) => emit(datePart, hour12, minute, e.target.value)}
+        >
+          <option value="AM">AM</option>
+          <option value="PM">PM</option>
+        </select>
+      </div>
+    </div>
+  );
+}
+// ────────────────────────────────────────────────────────────────────────────
+import DataTable from "@/components/ui/DataTable";
+import ActionButton from "@/components/ui/ActionButton";
+import Modal from "@/components/ui/Modal";
+import ConfirmDialog from "@/components/ui/ConfirmDialog";
+import DateTimePicker from "@/components/ui/DateTimePicker";
+import { apiClient } from "@/lib/api-client";
+import { routeCoachTemplatesApi } from "@/lib/api";
+import { formatDateTime } from "@/lib/utils";
+
+// EAT is UTC+3. Convert without depending on the browser's own timezone.
+const EAT_MS = 3 * 60 * 60 * 1000;
+// UTC ISO string → EAT "YYYY-MM-DDTHH:mm" for DateTimePicker display
+const isoToEAT = (iso: string): string =>
+  new Date(new Date(iso).getTime() + EAT_MS).toISOString().slice(0, 16);
+// EAT "YYYY-MM-DDTHH:mm" → UTC ISO string for API submission
+const eatToISO = (local: string): string =>
+  new Date(new Date(local + ":00Z").getTime() - EAT_MS).toISOString();
+// Extract HH:mm in EAT from a UTC ISO datetime (e.g. route stop planned time)
+const isoToEATTimePart = (iso: string): string | null => {
+  if (!iso) return null;
+  const eatMs = new Date(iso).getTime() + EAT_MS;
+  const msIntoDay = eatMs % (24 * 60 * 60 * 1000);
+  const h = Math.floor(msIntoDay / 3600000);
+  const m = Math.floor((msIntoDay % 3600000) / 60000);
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+};
 
 interface Schedule {
   id: string;
@@ -22,8 +140,19 @@ interface Schedule {
   train?: { id: string; name: string; number: string };
   originStation?: { id: string; name: string };
   destinationStation?: { id: string; name: string };
-  coachAssignments?: Array<{ coachId: string; positionNumber: number; coach?: { id: string; number: string } }>;
+  coachAssignments?: Array<{
+    coachId: string;
+    positionNumber: number;
+    coach?: { id: string; number: string };
+  }>;
   isPackageOnly?: boolean;
+  stopTimes?: Array<{
+    sequence: number;
+    stationId: string;
+    plannedDepartureAt: string | null;
+    plannedArrivalAt: string | null;
+    station?: { name: string };
+  }>;
 }
 
 interface Train {
@@ -52,133 +181,260 @@ export default function SchedulesPage() {
   const [showAddModal, setShowAddModal] = useState(false);
   const [showEditModal, setShowEditModal] = useState(false);
   const [editingSchedule, setEditingSchedule] = useState<Schedule | null>(null);
-  const [selectedSchedules, setSelectedSchedules] = useState<Set<string>>(new Set());
-  const [deleteConfirm, setDeleteConfirm] = useState<{ isOpen: boolean; item: any | null; isBulk?: boolean; error?: string; cascade?: boolean; cascadeChecked?: boolean }>(
-    { isOpen: false, item: null }
+  const [selectedSchedules, setSelectedSchedules] = useState<Set<string>>(
+    new Set(),
   );
+  const [deleteConfirm, setDeleteConfirm] = useState<{
+    isOpen: boolean;
+    item: any | null;
+    isBulk?: boolean;
+    error?: string;
+    cascade?: boolean;
+    cascadeChecked?: boolean;
+  }>({ isOpen: false, item: null });
   const [error, setError] = useState<string | null>(null);
   const queryClient = useQueryClient();
 
   const [bulkForm, setBulkForm] = useState({
-    trainId: '',
-    routeId: '',
-    startDateTime: '',
-    durationHours: '10',
-    repeatEveryDays: '2',
-    forNextDays: '15',
+    trainId: "",
+    routeId: "",
+    startDateTime: "",
+    durationHours: "10",
+    repeatEveryDays: "2",
+    forNextDays: "15",
   });
 
-  const [bulkCoachRows, setBulkCoachRows] = useState<{ coachId: string; positionNumber: number }[]>([]);
+  const [bulkCoachRows, setBulkCoachRows] = useState<
+    { coachId: string; positionNumber: number }[]
+  >([]);
 
-  const [addForm, setAddForm] = useState({ trainId: '', routeId: '', departureAt: '', arrivalAt: '' });
-  const [addCoachRows, setAddCoachRows] = useState<{ coachId: string; positionNumber: number }[]>([]);
+  const [addForm, setAddForm] = useState({
+    trainId: "",
+    routeId: "",
+    departureAt: "",
+    arrivalAt: "",
+  });
+  const [addCoachRows, setAddCoachRows] = useState<
+    { coachId: string; positionNumber: number }[]
+  >([]);
+  const [addStopTimes, setAddStopTimes] = useState<
+    {
+      sequence: number;
+      stationName: string;
+      plannedArrivalAt: string;
+      plannedDepartureAt: string;
+    }[]
+  >([]);
+  const [editStopTimes, setEditStopTimes] = useState<
+    {
+      sequence: number;
+      stationName: string;
+      plannedArrivalAt: string;
+      plannedDepartureAt: string;
+    }[]
+  >([]);
 
-  const { data: singleRouteTemplate, isLoading: singleTemplateLoading } = useQuery({
-    queryKey: ['route-coaches', addForm.routeId],
-    queryFn: () => routeCoachTemplatesApi.get(addForm.routeId),
+  const { data: singleRouteTemplate, isLoading: singleTemplateLoading } =
+    useQuery({
+      queryKey: ["route-coaches", addForm.routeId],
+      queryFn: () => routeCoachTemplatesApi.get(addForm.routeId),
+      enabled: !!addForm.routeId,
+    });
+
+  const { data: addRouteDetail } = useQuery({
+    queryKey: ["route-detail", addForm.routeId],
+    queryFn: () => apiClient.get<any>(`/routes/${addForm.routeId}`),
     enabled: !!addForm.routeId,
   });
 
+  const { data: editRouteDetail } = useQuery({
+    queryKey: ["route-detail", editingSchedule?.routeId],
+    queryFn: () => apiClient.get<any>(`/routes/${editingSchedule!.routeId}`),
+    enabled: !!editingSchedule?.routeId,
+  });
+
   useEffect(() => {
-    if (!addForm.routeId) { setAddCoachRows([]); return; }
-    const rows: any[] = Array.isArray(singleRouteTemplate) ? singleRouteTemplate : (singleRouteTemplate as any)?.coaches ?? [];
-    setAddCoachRows(rows.length ? rows.map((r: any) => ({ coachId: r.coachId ?? r.coach?.id, positionNumber: r.positionNumber })) : []);
+    if (!addForm.routeId) {
+      setAddCoachRows([]);
+      return;
+    }
+    const rows: any[] = Array.isArray(singleRouteTemplate)
+      ? singleRouteTemplate
+      : ((singleRouteTemplate as any)?.coaches ?? []);
+    setAddCoachRows(
+      rows.length
+        ? rows.map((r: any) => ({
+            coachId: r.coachId ?? r.coach?.id,
+            positionNumber: r.positionNumber,
+          }))
+        : [],
+    );
   }, [singleRouteTemplate, addForm.routeId]);
 
+  useEffect(() => {
+    const stops: any[] = (addRouteDetail as any)?.stops ?? [];
+    if (!stops.length) {
+      setAddStopTimes([]);
+      return;
+    }
+
+    const eatDateStr = addForm.departureAt
+      ? addForm.departureAt.slice(0, 10)
+      : null;
+
+    setAddStopTimes(
+      stops.map((s: any) => {
+        const arrTimePart = s.plannedArrivalTime
+          ? isoToEATTimePart(s.plannedArrivalTime)
+          : null;
+        const depTimePart = s.plannedDepartureTime
+          ? isoToEATTimePart(s.plannedDepartureTime)
+          : null;
+        return {
+          sequence: s.sequence,
+          stationName: s.station?.name ?? `Stop ${s.sequence}`,
+          plannedArrivalAt:
+            eatDateStr && arrTimePart ? `${eatDateStr}T${arrTimePart}` : "",
+          plannedDepartureAt:
+            eatDateStr && depTimePart ? `${eatDateStr}T${depTimePart}` : "",
+        };
+      }),
+    );
+  }, [addRouteDetail, addForm.departureAt]);
+
   // Fetch route coach template when route changes
   const { data: routeTemplate, isLoading: templateLoading } = useQuery({
-    queryKey: ['route-coaches', bulkForm.routeId],
+    queryKey: ["route-coaches", bulkForm.routeId],
     queryFn: () => routeCoachTemplatesApi.get(bulkForm.routeId),
     enabled: !!bulkForm.routeId,
   });
 
   useEffect(() => {
-    if (!bulkForm.routeId) { setBulkCoachRows([]); return; }
-    const rows: any[] = Array.isArray(routeTemplate) ? routeTemplate : (routeTemplate as any)?.coaches ?? [];
+    if (!bulkForm.routeId) {
+      setBulkCoachRows([]);
+      return;
+    }
+    const rows: any[] = Array.isArray(routeTemplate)
+      ? routeTemplate
+      : ((routeTemplate as any)?.coaches ?? []);
     setBulkCoachRows(
       rows.length
-        ? rows.map((r: any) => ({ coachId: r.coachId ?? r.coach?.id, positionNumber: r.positionNumber }))
-        : []
+        ? rows.map((r: any) => ({
+            coachId: r.coachId ?? r.coach?.id,
+            positionNumber: r.positionNumber,
+          }))
+        : [],
     );
   }, [routeTemplate, bulkForm.routeId]);
 
   const [editForm, setEditForm] = useState({
-    departureAt: '',
-    arrivalAt: '',
-    status: 'SCHEDULED',
+    departureAt: "",
+    arrivalAt: "",
+    status: "SCHEDULED",
     coachIds: [] as string[],
     isPackageOnly: false,
   });
 
+  useEffect(() => {
+    const stops: any[] = (editRouteDetail as any)?.stops ?? [];
+    if (!stops.length || !editingSchedule) return;
+    const hasRouteTimes = stops.some(
+      (s: any) => s.plannedArrivalTime || s.plannedDepartureTime,
+    );
+    if (!hasRouteTimes) return;
+    const eatDateStr = editForm.departureAt
+      ? editForm.departureAt.slice(0, 10)
+      : null;
+    setEditStopTimes(
+      stops.map((s: any) => {
+        const arrTimePart = s.plannedArrivalTime
+          ? isoToEATTimePart(s.plannedArrivalTime)
+          : null;
+        const depTimePart = s.plannedDepartureTime
+          ? isoToEATTimePart(s.plannedDepartureTime)
+          : null;
+        return {
+          sequence: s.sequence,
+          stationName: s.station?.name ?? `Stop ${s.sequence}`,
+          plannedArrivalAt:
+            eatDateStr && arrTimePart ? `${eatDateStr}T${arrTimePart}` : "",
+          plannedDepartureAt:
+            eatDateStr && depTimePart ? `${eatDateStr}T${depTimePart}` : "",
+        };
+      }),
+    );
+  }, [editRouteDetail, editingSchedule?.id, editForm.departureAt]); // eslint-disable-line react-hooks/exhaustive-deps
+
   const [filters, setFilters] = useState({
-    search: '',
-    trainId: '',
-    routeId: '',
-    date: '',
+    search: "",
+    trainId: "",
+    routeId: "",
+    date: "",
   });
 
   const { data: schedulesData, isLoading: schedulesLoading } = useQuery({
-    queryKey: ['schedules', filters],
+    queryKey: ["schedules", filters],
     queryFn: () => {
       const params = new URLSearchParams();
-      if (filters.trainId) params.append('trainId', filters.trainId);
-      if (filters.routeId) params.append('routeId', filters.routeId);
-      if (filters.date) params.append('date', filters.date);
+      if (filters.trainId) params.append("trainId", filters.trainId);
+      if (filters.routeId) params.append("routeId", filters.routeId);
+      if (filters.date) params.append("date", filters.date);
       return apiClient.get<Schedule[]>(`/schedules?${params.toString()}`);
     },
     retry: 1,
   });
 
   const { data: trainsData } = useQuery({
-    queryKey: ['trains'],
-    queryFn: () => apiClient.get<Train[]>('/fleet/trains'),
+    queryKey: ["trains"],
+    queryFn: () => apiClient.get<Train[]>("/fleet/trains"),
     retry: 1,
   });
 
   const { data: routesData } = useQuery({
-    queryKey: ['routes'],
-    queryFn: () => apiClient.get<Route[]>('/routes'),
+    queryKey: ["routes"],
+    queryFn: () => apiClient.get<Route[]>("/routes"),
     retry: 1,
   });
 
   const { data: coachesData } = useQuery({
-    queryKey: ['coaches'],
-    queryFn: () => apiClient.get<Coach[]>('/fleet/coaches'),
+    queryKey: ["coaches"],
+    queryFn: () => apiClient.get<Coach[]>("/fleet/coaches"),
     retry: 1,
   });
 
   const bulkGenerateMutation = useMutation({
-    mutationFn: (data: any) => apiClient.post('/schedules/bulk-generate', data),
+    mutationFn: (data: any) => apiClient.post("/schedules/bulk-generate", data),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['schedules'] });
+      queryClient.invalidateQueries({ queryKey: ["schedules"] });
       setShowModal(false);
       setBulkForm({
-        trainId: '',
-        routeId: '',
-        startDateTime: '',
-        durationHours: '12',
-        repeatEveryDays: '1',
-        forNextDays: '30',
+        trainId: "",
+        routeId: "",
+        startDateTime: "",
+        durationHours: "12",
+        repeatEveryDays: "1",
+        forNextDays: "30",
       });
       setBulkCoachRows([]);
       setError(null);
     },
     onError: (err: any) => {
-      setError(err.response?.data?.message || 'Failed to generate schedules');
+      setError(err.response?.data?.message || "Failed to generate schedules");
     },
   });
 
   const createScheduleMutation = useMutation({
-    mutationFn: (data: any) => apiClient.post('/schedules', data),
+    mutationFn: (data: any) => apiClient.post("/schedules", data),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['schedules'] });
+      queryClient.invalidateQueries({ queryKey: ["schedules"] });
       setShowAddModal(false);
-      setAddForm({ trainId: '', routeId: '', departureAt: '', arrivalAt: '' });
+      setAddForm({ trainId: "", routeId: "", departureAt: "", arrivalAt: "" });
       setAddCoachRows([]);
+      setAddStopTimes([]);
       setError(null);
     },
     onError: (err: any) => {
-      setError(err.response?.data?.message || 'Failed to create schedule');
+      setError(err.response?.data?.message || "Failed to create schedule");
     },
   });
 
@@ -186,43 +442,63 @@ export default function SchedulesPage() {
     mutationFn: (data: { id: string; payload: any }) =>
       apiClient.patch(`/schedules/${data.id}`, data.payload),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['schedules'] });
+      queryClient.invalidateQueries({ queryKey: ["schedules"] });
       setShowEditModal(false);
       setEditingSchedule(null);
+      setEditStopTimes([]);
       setError(null);
     },
     onError: (err: any) => {
-      setError(err.response?.data?.message || 'Failed to update schedule');
+      setError(err.response?.data?.message || "Failed to update schedule");
     },
   });
 
   const deleteScheduleMutation = useMutation({
-    mutationFn: ({ id, cascade }: { id: string; cascade?: boolean }) => apiClient.delete(`/schedules/${id}${cascade ? '?cascade=true' : ''}`),
+    mutationFn: ({ id, cascade }: { id: string; cascade?: boolean }) =>
+      apiClient.delete(`/schedules/${id}${cascade ? "?cascade=true" : ""}`),
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['schedules'] });
+      queryClient.invalidateQueries({ queryKey: ["schedules"] });
     },
     onError: (err: any) => {
-      const msg = err?.response?.data?.message || err?.message || 'Failed to delete schedule';
-      const isFkError = msg?.includes('Cannot delete') || err?.response?.status === 400;
+      const msg =
+        err?.response?.data?.message ||
+        err?.message ||
+        "Failed to delete schedule";
+      const isFkError =
+        msg?.includes("Cannot delete") || err?.response?.status === 400;
       if (isFkError && !deleteConfirm.cascade) {
-        setDeleteConfirm(prev => ({ ...prev, cascade: true, cascadeChecked: false, error: Array.isArray(msg) ? msg.join(' ') : msg }));
+        setDeleteConfirm((prev) => ({
+          ...prev,
+          cascade: true,
+          cascadeChecked: false,
+          error: Array.isArray(msg) ? msg.join(" ") : msg,
+        }));
       } else {
-        setDeleteConfirm(prev => ({ ...prev, error: Array.isArray(msg) ? msg.join(' ') : msg }));
+        setDeleteConfirm((prev) => ({
+          ...prev,
+          error: Array.isArray(msg) ? msg.join(" ") : msg,
+        }));
       }
     },
   });
 
   const bulkDeleteMutation = useMutation({
     mutationFn: async (ids: string[]) => {
-      await Promise.all(ids.map(id => apiClient.delete(`/schedules/${id}`)));
+      await Promise.all(ids.map((id) => apiClient.delete(`/schedules/${id}`)));
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['schedules'] });
+      queryClient.invalidateQueries({ queryKey: ["schedules"] });
       setSelectedSchedules(new Set());
     },
     onError: (err: any) => {
-      const msg = err?.response?.data?.message || err?.message || 'Failed to delete schedules';
-      setDeleteConfirm(prev => ({ ...prev, error: Array.isArray(msg) ? msg.join(' ') : msg }));
+      const msg =
+        err?.response?.data?.message ||
+        err?.message ||
+        "Failed to delete schedules";
+      setDeleteConfirm((prev) => ({
+        ...prev,
+        error: Array.isArray(msg) ? msg.join(" ") : msg,
+      }));
     },
   });
 
@@ -231,14 +507,14 @@ export default function SchedulesPage() {
     setError(null);
 
     if (!bulkForm.trainId || !bulkForm.routeId || !bulkForm.startDateTime) {
-      setError('Train, route, and start date/time are required');
+      setError("Train, route, and start date/time are required");
       return;
     }
 
     const payload: any = {
       trainId: bulkForm.trainId,
       routeId: bulkForm.routeId,
-      startDateTime: bulkForm.startDateTime,
+      startDateTime: new Date(bulkForm.startDateTime).toISOString(),
       durationHours: parseInt(bulkForm.durationHours),
       repeatEveryDays: parseInt(bulkForm.repeatEveryDays),
       forNextDays: parseInt(bulkForm.forNextDays),
@@ -255,16 +531,44 @@ export default function SchedulesPage() {
   const handleAddSubmit = async (e: React.FormEvent<HTMLFormElement>) => {
     e.preventDefault();
     setError(null);
-    const dep = new Date(addForm.departureAt);
-    const arr = new Date(addForm.arrivalAt);
-    if (arr <= dep) { setError('Arrival must be after departure'); return; }
+    if (!addForm.departureAt || !addForm.arrivalAt) {
+      setError("Please select departure and arrival date & time");
+      return;
+    }
+    if (
+      new Date(addForm.arrivalAt + ":00Z") <=
+      new Date(addForm.departureAt + ":00Z")
+    ) {
+      setError("Arrival must be after departure");
+      return;
+    }
+
+    const filledStops = addStopTimes.filter(
+      (s) => s.plannedDepartureAt || s.plannedArrivalAt,
+    );
+    const plannedTimes =
+      filledStops.length === addStopTimes.length && addStopTimes.length > 0
+        ? addStopTimes.map((s) => ({
+            sequence: s.sequence,
+            ...(s.plannedArrivalAt
+              ? { plannedArrivalAt: eatToISO(s.plannedArrivalAt) }
+              : {}),
+            ...(s.plannedDepartureAt
+              ? { plannedDepartureAt: eatToISO(s.plannedDepartureAt) }
+              : {}),
+          }))
+        : undefined;
+
     const validCoaches = addCoachRows.filter((r) => r.coachId);
     await createScheduleMutation.mutateAsync({
       trainId: addForm.trainId,
       routeId: addForm.routeId,
-      departureAt: dep.toISOString(),
-      arrivalAt: arr.toISOString(),
-      ...(validCoaches.length > 0 && { coachIds: validCoaches.map((r) => r.coachId) }),
+      departureAt: eatToISO(addForm.departureAt),
+      arrivalAt: eatToISO(addForm.arrivalAt),
+      ...(plannedTimes ? { plannedTimes } : {}),
+      ...(validCoaches.length > 0 && {
+        coachIds: validCoaches.map((r) => r.coachId),
+      }),
     });
   };
 
@@ -274,24 +578,46 @@ export default function SchedulesPage() {
 
     if (!editingSchedule) return;
 
-    // Convert local datetime-local values to UTC for API
-    const depLocal = new Date(editForm.departureAt);
-    const arrLocal = new Date(editForm.arrivalAt);
-    
-    if (arrLocal <= depLocal) {
-      setError('Arrival time must be after departure time');
+    if (!editForm.departureAt || !editForm.arrivalAt) {
+      setError("Please select departure and arrival date & time");
       return;
     }
 
+    if (
+      new Date(editForm.arrivalAt + ":00Z") <=
+      new Date(editForm.departureAt + ":00Z")
+    ) {
+      setError("Arrival time must be after departure time");
+      return;
+    }
+
+    const filledEditStops = editStopTimes.filter(
+      (s) => s.plannedDepartureAt || s.plannedArrivalAt,
+    );
+    const editPlannedTimes =
+      filledEditStops.length === editStopTimes.length &&
+      editStopTimes.length > 0
+        ? editStopTimes.map((s) => ({
+            sequence: s.sequence,
+            ...(s.plannedArrivalAt
+              ? { plannedArrivalAt: eatToISO(s.plannedArrivalAt) }
+              : {}),
+            ...(s.plannedDepartureAt
+              ? { plannedDepartureAt: eatToISO(s.plannedDepartureAt) }
+              : {}),
+          }))
+        : undefined;
+
     const payload: any = {
-      departureAt: depLocal.toISOString(),
-      arrivalAt: arrLocal.toISOString(),
+      departureAt: eatToISO(editForm.departureAt),
+      arrivalAt: eatToISO(editForm.arrivalAt),
       status: editForm.status,
       isPackageOnly: editForm.isPackageOnly,
       coaches: editForm.coachIds.map((coachId: string, idx: number) => ({
         coachId,
         positionNumber: idx + 1,
       })),
+      ...(editPlannedTimes ? { plannedTimes: editPlannedTimes } : {}),
     };
 
     await updateScheduleMutation.mutateAsync({
@@ -306,17 +632,24 @@ export default function SchedulesPage() {
 
   const handleBulkDelete = () => {
     if (selectedSchedules.size === 0) return;
-    setDeleteConfirm({ isOpen: true, item: Array.from(selectedSchedules), isBulk: true });
+    setDeleteConfirm({
+      isOpen: true,
+      item: Array.from(selectedSchedules),
+      isBulk: true,
+    });
   };
 
   const confirmDelete = async () => {
-    setDeleteConfirm(prev => ({ ...prev, error: undefined }));
+    setDeleteConfirm((prev) => ({ ...prev, error: undefined }));
     try {
       if (deleteConfirm.isBulk) {
         const ids = deleteConfirm.item as string[];
         await bulkDeleteMutation.mutateAsync(ids);
       } else if (deleteConfirm.item) {
-        await deleteScheduleMutation.mutateAsync({ id: deleteConfirm.item.id, cascade: deleteConfirm.cascade && deleteConfirm.cascadeChecked });
+        await deleteScheduleMutation.mutateAsync({
+          id: deleteConfirm.item.id,
+          cascade: deleteConfirm.cascade && deleteConfirm.cascadeChecked,
+        });
       }
       setDeleteConfirm({ isOpen: false, item: null });
     } catch {
@@ -327,34 +660,45 @@ export default function SchedulesPage() {
   const handleEditClick = (schedule: Schedule) => {
     setEditingSchedule(schedule);
 
-    // Convert UTC dates to local time for datetime-local input
-    // datetime-local expects local time (no timezone info)
-    const dep = new Date(schedule.departureAt);
-    const arr = new Date(schedule.arrivalAt);
-
-    // Convert to local time by adding the timezone offset
-    const depLocal = new Date(dep.getTime() + dep.getTimezoneOffset() * 60000);
-    const arrLocal = new Date(arr.getTime() + arr.getTimezoneOffset() * 60000);
-
-    // Format for datetime-local input (YYYY-MM-DDTHH:mm)
-    const depStr = depLocal.toISOString().slice(0, 16);
-    const arrStr = arrLocal.toISOString().slice(0, 16);
-
     setEditForm({
-      departureAt: depStr,
-      arrivalAt: arrStr,
+      departureAt: isoToEAT(schedule.departureAt),
+      arrivalAt: isoToEAT(schedule.arrivalAt),
       status: schedule.status,
       coachIds: schedule.coachAssignments?.map((ca: any) => ca.coachId) || [],
       isPackageOnly: schedule.isPackageOnly ?? false,
     });
+
+    if (schedule.stopTimes && schedule.stopTimes.length > 0) {
+      const toDatetimeLocal = (iso: string | null) =>
+        iso ? isoToEAT(iso) : "";
+      setEditStopTimes(
+        schedule.stopTimes.map((st) => ({
+          sequence: st.sequence,
+          stationName: st.station?.name ?? `Stop ${st.sequence}`,
+          plannedArrivalAt: toDatetimeLocal(st.plannedArrivalAt),
+          plannedDepartureAt: toDatetimeLocal(st.plannedDepartureAt),
+        })),
+      );
+    } else {
+      setEditStopTimes([]);
+    }
+
     setError(null);
     setShowEditModal(true);
   };
 
-  const schedules = Array.isArray(schedulesData) ? schedulesData : (schedulesData as any)?.items || [];
-  const trains = Array.isArray(trainsData) ? trainsData : (trainsData as any)?.items || [];
-  const routes = Array.isArray(routesData) ? routesData : (routesData as any)?.items || [];
-  const coaches = Array.isArray(coachesData) ? coachesData : (coachesData as any)?.items || [];
+  const schedules = Array.isArray(schedulesData)
+    ? schedulesData
+    : (schedulesData as any)?.items || [];
+  const trains = Array.isArray(trainsData)
+    ? trainsData
+    : (trainsData as any)?.items || [];
+  const routes = Array.isArray(routesData)
+    ? routesData
+    : (routesData as any)?.items || [];
+  const coaches = Array.isArray(coachesData)
+    ? coachesData
+    : (coachesData as any)?.items || [];
 
   const filteredSchedules = schedules.filter((schedule: Schedule) => {
     if (!filters.search) return true;
@@ -369,23 +713,28 @@ export default function SchedulesPage() {
   });
 
   const statusMap: Record<string, string> = {
-    SCHEDULED: 'edr-badge-info',
-    BOARDING: 'edr-badge-warning',
-    EN_ROUTE: 'edr-badge-success',
-    ARRIVED: 'edr-badge-secondary',
-    CANCELLED: 'edr-badge-danger',
+    SCHEDULED: "edr-badge-info",
+    BOARDING: "edr-badge-warning",
+    EN_ROUTE: "edr-badge-success",
+    ARRIVED: "edr-badge-secondary",
+    CANCELLED: "edr-badge-danger",
   };
 
   const scheduleColumns = [
     {
-      key: 'checkbox',
+      key: "checkbox",
       label: (
         <input
           type="checkbox"
-          checked={selectedSchedules.size === filteredSchedules.length && filteredSchedules.length > 0}
+          checked={
+            selectedSchedules.size === filteredSchedules.length &&
+            filteredSchedules.length > 0
+          }
           onChange={(e) => {
             if (e.target.checked) {
-              setSelectedSchedules(new Set(filteredSchedules.map((s: Schedule) => s.id)));
+              setSelectedSchedules(
+                new Set(filteredSchedules.map((s: Schedule) => s.id)),
+              );
             } else {
               setSelectedSchedules(new Set());
             }
@@ -411,50 +760,52 @@ export default function SchedulesPage() {
       ),
     },
     {
-      key: 'train.name',
-      label: 'Train',
+      key: "train.name",
+      label: "Train",
       sortable: true,
       render: (schedule: Schedule) => (
-        <div className="font-medium font-mono">
-          {schedule.train?.number}
-        </div>
+        <div className="font-medium font-mono">{schedule.train?.number}</div>
       ),
     },
     {
-      key: 'route',
-      label: 'Route',
+      key: "route",
+      label: "Route",
       sortable: true,
       render: (schedule: Schedule) => (
         <div className="flex items-center gap-2">
           <span className="text-sm font-medium">
-            {schedule.originStation?.name || 'Unknown'}
+            {schedule.originStation?.name || "Unknown"}
           </span>
           <span className="text-muted-foreground">→</span>
           <span className="text-sm font-medium">
-            {schedule.destinationStation?.name || 'Unknown'}
+            {schedule.destinationStation?.name || "Unknown"}
           </span>
         </div>
       ),
     },
     {
-      key: 'departureAt',
-      label: 'Departure',
+      key: "departureAt",
+      label: "Departure",
       sortable: true,
       render: (schedule: Schedule) => (
-        <span className="font-mono text-sm">{formatDateTime(schedule.departureAt)}</span>
+        <span className="font-mono text-sm">
+          {formatDateTime(schedule.departureAt)}
+        </span>
       ),
     },
     {
-      key: 'arrivalAt',
-      label: 'Arrival',
+      key: "arrivalAt",
+      label: "Arrival",
       sortable: true,
       render: (schedule: Schedule) => (
-        <span className="font-mono text-sm">{formatDateTime(schedule.arrivalAt)}</span>
+        <span className="font-mono text-sm">
+          {formatDateTime(schedule.arrivalAt)}
+        </span>
       ),
     },
     {
-      key: 'coachAssignments',
-      label: 'Coaches',
+      key: "coachAssignments",
+      label: "Coaches",
       render: (schedule: Schedule) => (
         <span className="text-sm font-medium">
           {schedule.coachAssignments?.length || 0}
@@ -462,11 +813,13 @@ export default function SchedulesPage() {
       ),
     },
     {
-      key: 'status',
-      label: 'Status',
+      key: "status",
+      label: "Status",
       render: (schedule: Schedule) => (
         <div className="flex items-center gap-2">
-          <span className={`edr-badge ${statusMap[schedule.status] || 'edr-badge-info'}`}>
+          <span
+            className={`edr-badge ${statusMap[schedule.status] || "edr-badge-info"}`}
+          >
             {schedule.status}
           </span>
           {schedule.isPackageOnly && (
@@ -478,30 +831,35 @@ export default function SchedulesPage() {
   ] as any;
 
   const cancelScheduleMutation = useMutation({
-    mutationFn: (id: string) => apiClient.patch(`/schedules/${id}/status`, { status: 'CANCELLED' }),
-    onSuccess: () => queryClient.invalidateQueries({ queryKey: ['schedules'] }),
+    mutationFn: (id: string) =>
+      apiClient.patch(`/schedules/${id}/status`, { status: "CANCELLED" }),
+    onSuccess: () => queryClient.invalidateQueries({ queryKey: ["schedules"] }),
   });
 
-  const [cancelConfirm, setCancelConfirm] = useState<{ isOpen: boolean; item: Schedule | null }>({ isOpen: false, item: null });
+  const [cancelConfirm, setCancelConfirm] = useState<{
+    isOpen: boolean;
+    item: Schedule | null;
+  }>({ isOpen: false, item: null });
 
   const scheduleActions = [
     {
-      label: 'Edit',
+      label: "Edit",
       onClick: handleEditClick,
-      variant: 'secondary' as const,
+      variant: "secondary" as const,
       icon: Edit,
     },
     {
-      label: 'Cancel',
-      onClick: (schedule: Schedule) => setCancelConfirm({ isOpen: true, item: schedule }),
-      variant: 'danger' as const,
+      label: "Cancel",
+      onClick: (schedule: Schedule) =>
+        setCancelConfirm({ isOpen: true, item: schedule }),
+      variant: "danger" as const,
       icon: X,
-      hidden: (schedule: Schedule) => schedule.status === 'CANCELLED',
+      hidden: (schedule: Schedule) => schedule.status === "CANCELLED",
     },
     {
-      label: 'Delete',
+      label: "Delete",
       onClick: handleDelete,
-      variant: 'danger' as const,
+      variant: "danger" as const,
       icon: Trash2,
     },
   ];
@@ -510,8 +868,12 @@ export default function SchedulesPage() {
     <div className="space-y-6">
       <div className="flex items-center justify-between">
         <div>
-          <h1 className="text-3xl font-bold text-foreground">Schedule Management</h1>
-          <p className="text-muted-foreground mt-1">Create and manage train schedules</p>
+          <h1 className="text-3xl font-bold text-foreground">
+            Schedule Management
+          </h1>
+          <p className="text-muted-foreground mt-1">
+            Create and manage train schedules
+          </p>
         </div>
         <div className="flex gap-2">
           {selectedSchedules.size > 0 && (
@@ -520,13 +882,17 @@ export default function SchedulesPage() {
               variant="danger"
               loading={bulkDeleteMutation.isPending}
             >
-              Delete {selectedSchedules.size} Schedule{selectedSchedules.size !== 1 ? 's' : ''}
+              Delete {selectedSchedules.size} Schedule
+              {selectedSchedules.size !== 1 ? "s" : ""}
             </ActionButton>
           )}
           <ActionButton
             icon={Plus}
             variant="secondary"
-            onClick={() => { setError(null); setShowAddModal(true); }}
+            onClick={() => {
+              setError(null);
+              setShowAddModal(true);
+            }}
           >
             Add Schedule
           </ActionButton>
@@ -551,7 +917,9 @@ export default function SchedulesPage() {
                 type="text"
                 placeholder="Search by train name, number, station, or status..."
                 value={filters.search}
-                onChange={(e) => setFilters({ ...filters, search: e.target.value })}
+                onChange={(e) =>
+                  setFilters({ ...filters, search: e.target.value })
+                }
                 className="input pl-10 w-full"
               />
             </div>
@@ -561,7 +929,9 @@ export default function SchedulesPage() {
                 <label className="label text-sm">Train</label>
                 <select
                   value={filters.trainId}
-                  onChange={(e) => setFilters({ ...filters, trainId: e.target.value })}
+                  onChange={(e) =>
+                    setFilters({ ...filters, trainId: e.target.value })
+                  }
                   className="input"
                 >
                   <option value="">All Trains</option>
@@ -577,7 +947,9 @@ export default function SchedulesPage() {
                 <label className="label text-sm">Route</label>
                 <select
                   value={filters.routeId}
-                  onChange={(e) => setFilters({ ...filters, routeId: e.target.value })}
+                  onChange={(e) =>
+                    setFilters({ ...filters, routeId: e.target.value })
+                  }
                   className="input"
                 >
                   <option value="">All Routes</option>
@@ -594,7 +966,9 @@ export default function SchedulesPage() {
                 <input
                   type="date"
                   value={filters.date}
-                  onChange={(e) => setFilters({ ...filters, date: e.target.value })}
+                  onChange={(e) =>
+                    setFilters({ ...filters, date: e.target.value })
+                  }
                   className="input"
                 />
               </div>
@@ -602,7 +976,14 @@ export default function SchedulesPage() {
               <div className="flex items-end">
                 <ActionButton
                   variant="secondary"
-                  onClick={() => setFilters({ search: '', trainId: '', routeId: '', date: '' })}
+                  onClick={() =>
+                    setFilters({
+                      search: "",
+                      trainId: "",
+                      routeId: "",
+                      date: "",
+                    })
+                  }
                 >
                   Clear Filters
                 </ActionButton>
@@ -618,7 +999,8 @@ export default function SchedulesPage() {
             </div>
           ) : filteredSchedules.length === 0 ? (
             <div className="text-center py-8 text-muted-foreground">
-              No schedules found. {filters.search && 'Try adjusting your search.'}
+              No schedules found.{" "}
+              {filters.search && "Try adjusting your search."}
             </div>
           ) : (
             <DataTable
@@ -642,7 +1024,7 @@ export default function SchedulesPage() {
           }
         }}
         title="Cancel Schedule"
-        message={`Cancel the schedule departing ${cancelConfirm.item ? formatDateTime(cancelConfirm.item.departureAt) : ''}? Passengers with bookings will need to be notified separately.`}
+        message={`Cancel the schedule departing ${cancelConfirm.item ? formatDateTime(cancelConfirm.item.departureAt) : ""}? Passengers with bookings will need to be notified separately.`}
         confirmText="Cancel Schedule"
         isDanger={true}
         isLoading={cancelScheduleMutation.isPending}
@@ -652,46 +1034,99 @@ export default function SchedulesPage() {
         isOpen={deleteConfirm.isOpen}
         onClose={() => setDeleteConfirm({ isOpen: false, item: null })}
         onConfirm={confirmDelete}
-        title={deleteConfirm.isBulk ? 'Delete Multiple Schedules' : 'Delete Schedule'}
+        title={
+          deleteConfirm.isBulk ? "Delete Multiple Schedules" : "Delete Schedule"
+        }
         message={
           deleteConfirm.isBulk
             ? `Are you sure you want to delete ${Array.isArray(deleteConfirm.item) ? deleteConfirm.item.length : 0} schedule(s)? This action cannot be undone.`
             : `Are you sure you want to delete this schedule departing on ${
-                deleteConfirm.item ? formatDateTime(deleteConfirm.item.departureAt) : ''
+                deleteConfirm.item
+                  ? formatDateTime(deleteConfirm.item.departureAt)
+                  : ""
               }?`
         }
         confirmText="Delete"
         isDanger={true}
-        isLoading={deleteScheduleMutation.isPending || bulkDeleteMutation.isPending}
+        isLoading={
+          deleteScheduleMutation.isPending || bulkDeleteMutation.isPending
+        }
         error={deleteConfirm.error}
-        warning={!deleteConfirm.cascade ? "Schedules with existing bookings cannot be deleted." : undefined}
-        cascadeWarning={deleteConfirm.cascade ? "This schedule has related bookings or tickets that will also be permanently deleted." : undefined}
+        warning={
+          !deleteConfirm.cascade
+            ? "Schedules with existing bookings cannot be deleted."
+            : undefined
+        }
+        cascadeWarning={
+          deleteConfirm.cascade
+            ? "This schedule has related bookings or tickets that will also be permanently deleted."
+            : undefined
+        }
         cascadeChecked={deleteConfirm.cascadeChecked}
-        onCascadeChange={(checked) => setDeleteConfirm(prev => ({ ...prev, cascadeChecked: checked }))}
+        onCascadeChange={(checked) =>
+          setDeleteConfirm((prev) => ({ ...prev, cascadeChecked: checked }))
+        }
       />
 
       <Modal
         isOpen={showAddModal}
-        onClose={() => { setShowAddModal(false); setAddForm({ trainId: '', routeId: '', departureAt: '', arrivalAt: '' }); setAddCoachRows([]); setError(null); }}
+        onClose={() => {
+          setShowAddModal(false);
+          setAddForm({
+            trainId: "",
+            routeId: "",
+            departureAt: "",
+            arrivalAt: "",
+          });
+          setAddCoachRows([]);
+          setAddStopTimes([]);
+          setError(null);
+        }}
         title="Add Schedule"
         size="lg"
       >
         <form onSubmit={handleAddSubmit} className="space-y-4">
-          {error && <div className="bg-red-50 p-3 rounded-lg text-sm text-red-800">{error}</div>}
+          {error && (
+            <div className="bg-red-50 p-3 rounded-lg text-sm text-red-800">
+              {error}
+            </div>
+          )}
 
           <div className="grid grid-cols-2 gap-4">
             <div>
               <label className="label">Train *</label>
-              <select className="input" value={addForm.trainId} onChange={(e) => setAddForm({ ...addForm, trainId: e.target.value })} required>
+              <select
+                className="input"
+                value={addForm.trainId}
+                onChange={(e) =>
+                  setAddForm({ ...addForm, trainId: e.target.value })
+                }
+                required
+              >
                 <option value="">Select Train</option>
-                {trains.map((t: Train) => <option key={t.id} value={t.id}>{t.number} ({t.name})</option>)}
+                {trains.map((t: Train) => (
+                  <option key={t.id} value={t.id}>
+                    {t.number} ({t.name})
+                  </option>
+                ))}
               </select>
             </div>
             <div>
               <label className="label">Route *</label>
-              <select className="input" value={addForm.routeId} onChange={(e) => setAddForm({ ...addForm, routeId: e.target.value })} required>
+              <select
+                className="input"
+                value={addForm.routeId}
+                onChange={(e) =>
+                  setAddForm({ ...addForm, routeId: e.target.value })
+                }
+                required
+              >
                 <option value="">Select Route</option>
-                {routes.map((r: Route) => <option key={r.id} value={r.id}>{r.code} ({r.name})</option>)}
+                {routes.map((r: Route) => (
+                  <option key={r.id} value={r.id}>
+                    {r.code} ({r.name})
+                  </option>
+                ))}
               </select>
             </div>
           </div>
@@ -699,62 +1134,265 @@ export default function SchedulesPage() {
           <div className="grid grid-cols-2 gap-4">
             <div>
               <label className="label">Departure *</label>
-              <input type="datetime-local" className="input" value={addForm.departureAt} onChange={(e) => setAddForm({ ...addForm, departureAt: e.target.value })} required />
+              <DateTimePicker
+                value={addForm.departureAt}
+                onChange={(v) => setAddForm({ ...addForm, departureAt: v })}
+                placeholder="Select departure"
+              />
             </div>
             <div>
               <label className="label">Arrival *</label>
-              <input type="datetime-local" className="input" value={addForm.arrivalAt} onChange={(e) => setAddForm({ ...addForm, arrivalAt: e.target.value })} required />
+              <DateTimePicker
+                value={addForm.arrivalAt}
+                onChange={(v) => setAddForm({ ...addForm, arrivalAt: v })}
+                placeholder="Select arrival"
+              />
             </div>
           </div>
 
+          {addStopTimes.length > 0 && (
+            <div className="border-t pt-4">
+              <div className="flex items-center justify-between mb-3">
+                <div>
+                  <label className="label mb-0">Stop Times</label>
+                  <p className="text-xs text-muted-foreground mt-0.5">
+                    Set planned times for each stop. Leave all blank to
+                    auto-generate from distance.
+                  </p>
+                </div>
+                <button
+                  type="button"
+                  className="text-xs text-primary underline"
+                  onClick={() => {
+                    const dep = addForm.departureAt
+                      ? new Date(addForm.departureAt + ":00Z")
+                      : null;
+                    const arr = addForm.arrivalAt
+                      ? new Date(addForm.arrivalAt + ":00Z")
+                      : null;
+                    if (!dep || !arr || arr <= dep) return;
+                    const stops = (addRouteDetail as any)?.stops ?? [];
+                    const totalDuration = arr.getTime() - dep.getTime();
+                    const totalDistance =
+                      stops[stops.length - 1]?.distanceKm || 1;
+                    setAddStopTimes(
+                      addStopTimes.map((s, i) => {
+                        const stop = stops.find(
+                          (st: any) => st.sequence === s.sequence,
+                        );
+                        const dist = stop?.distanceKm ?? 0;
+                        const t = new Date(
+                          dep.getTime() +
+                            (dist / totalDistance) * totalDuration,
+                        );
+                        const fmt = t.toISOString().slice(0, 16);
+                        return {
+                          ...s,
+                          plannedArrivalAt: i === 0 ? "" : fmt,
+                          plannedDepartureAt:
+                            i === addStopTimes.length - 1 ? "" : fmt,
+                        };
+                      }),
+                    );
+                  }}
+                >
+                  Auto-fill from departure/arrival
+                </button>
+              </div>
+              <div className="overflow-x-auto">
+                <table className="w-full text-sm">
+                  <thead>
+                    <tr className="text-left text-xs text-muted-foreground border-b">
+                      <th className="pb-2 pr-3 font-medium">#</th>
+                      <th className="pb-2 pr-3 font-medium">Station</th>
+                      <th className="pb-2 pr-3 font-medium">Planned Arrival</th>
+                      <th className="pb-2 font-medium">Planned Departure</th>
+                    </tr>
+                  </thead>
+                  <tbody className="divide-y">
+                    {addStopTimes.map((stop, i) => {
+                      const isFirst = i === 0;
+                      const isLast = i === addStopTimes.length - 1;
+                      return (
+                        <tr key={stop.sequence}>
+                          <td className="py-2 pr-3 text-muted-foreground">
+                            {stop.sequence}
+                          </td>
+                          <td className="py-2 pr-3 font-medium whitespace-nowrap">
+                            {stop.stationName}
+                          </td>
+                          <td className="py-2 pr-3 min-w-[200px]">
+                            {isFirst ? (
+                              <span className="text-xs text-muted-foreground italic">
+                                —
+                              </span>
+                            ) : (
+                              <DateTimePicker
+                                value={stop.plannedArrivalAt}
+                                onChange={(v) => {
+                                  const updated = [...addStopTimes];
+                                  updated[i] = {
+                                    ...updated[i],
+                                    plannedArrivalAt: v,
+                                  };
+                                  setAddStopTimes(updated);
+                                }}
+                                placeholder="Pick arrival"
+                              />
+                            )}
+                          </td>
+                          <td className="py-2 min-w-[200px]">
+                            {isLast ? (
+                              <span className="text-xs text-muted-foreground italic">
+                                —
+                              </span>
+                            ) : (
+                              <DateTimePicker
+                                value={stop.plannedDepartureAt}
+                                onChange={(v) => {
+                                  const updated = [...addStopTimes];
+                                  updated[i] = {
+                                    ...updated[i],
+                                    plannedDepartureAt: v,
+                                  };
+                                  setAddStopTimes(updated);
+                                }}
+                                placeholder="Pick departure"
+                              />
+                            )}
+                          </td>
+                        </tr>
+                      );
+                    })}
+                  </tbody>
+                </table>
+              </div>
+            </div>
+          )}
+
           <div className="border-t pt-4">
             <div className="flex items-center justify-between mb-2">
               <label className="label mb-0">Coaches</label>
               <div className="flex items-center gap-3">
                 {singleTemplateLoading && addForm.routeId && (
-                  <span className="text-xs text-muted-foreground flex items-center gap-1"><Loader2 className="h-3 w-3 animate-spin" /> Loading template…</span>
+                  <span className="text-xs text-muted-foreground flex items-center gap-1">
+                    <Loader2 className="h-3 w-3 animate-spin" /> Loading
+                    template…
+                  </span>
                 )}
-                {!addForm.routeId && <span className="text-xs text-muted-foreground">Select a route to load its coach template</span>}
-                <ActionButton type="button" variant="secondary" size="sm" icon={Plus}
-                  disabled={addCoachRows.filter(r => r.coachId).length >= coaches.length}
-                  onClick={() => setAddCoachRows([...addCoachRows, { coachId: '', positionNumber: addCoachRows.length + 1 }])}>
+                {!addForm.routeId && (
+                  <span className="text-xs text-muted-foreground">
+                    Select a route to load its coach template
+                  </span>
+                )}
+                <ActionButton
+                  type="button"
+                  variant="secondary"
+                  size="sm"
+                  icon={Plus}
+                  disabled={
+                    addCoachRows.filter((r) => r.coachId).length >=
+                    coaches.length
+                  }
+                  onClick={() =>
+                    setAddCoachRows([
+                      ...addCoachRows,
+                      { coachId: "", positionNumber: addCoachRows.length + 1 },
+                    ])
+                  }
+                >
                   Add Coach
                 </ActionButton>
               </div>
             </div>
             {addCoachRows.length === 0 ? (
-              <p className="text-sm text-muted-foreground py-2">No coaches assigned.</p>
+              <p className="text-sm text-muted-foreground py-2">
+                No coaches assigned.
+              </p>
             ) : (
               <div className="space-y-2">
-                {addCoachRows.length > 1 && <p className="text-xs text-muted-foreground">Drag <GripVertical className="inline h-3 w-3" /> to reorder</p>}
+                {addCoachRows.length > 1 && (
+                  <p className="text-xs text-muted-foreground">
+                    Drag <GripVertical className="inline h-3 w-3" /> to reorder
+                  </p>
+                )}
                 {addCoachRows.map((row, i) => {
-                  const selectedIds = new Set(addCoachRows.map((r) => r.coachId).filter(Boolean));
+                  const selectedIds = new Set(
+                    addCoachRows.map((r) => r.coachId).filter(Boolean),
+                  );
                   return (
-                    <div key={i} draggable
-                      onDragStart={(e) => e.dataTransfer.setData('add-coach-idx', i.toString())}
-                      onDragOver={(e) => { e.preventDefault(); (e.currentTarget as HTMLElement).style.opacity = '0.5'; }}
-                      onDragLeave={(e) => { (e.currentTarget as HTMLElement).style.opacity = '1'; }}
+                    <div
+                      key={i}
+                      draggable
+                      onDragStart={(e) =>
+                        e.dataTransfer.setData("add-coach-idx", i.toString())
+                      }
+                      onDragOver={(e) => {
+                        e.preventDefault();
+                        (e.currentTarget as HTMLElement).style.opacity = "0.5";
+                      }}
+                      onDragLeave={(e) => {
+                        (e.currentTarget as HTMLElement).style.opacity = "1";
+                      }}
                       onDrop={(e) => {
-                        e.preventDefault(); (e.currentTarget as HTMLElement).style.opacity = '1';
-                        const src = parseInt(e.dataTransfer.getData('add-coach-idx'));
+                        e.preventDefault();
+                        (e.currentTarget as HTMLElement).style.opacity = "1";
+                        const src = parseInt(
+                          e.dataTransfer.getData("add-coach-idx"),
+                        );
                         if (src === i) return;
                         const reordered = [...addCoachRows];
                         const [moved] = reordered.splice(src, 1);
                         reordered.splice(i, 0, moved);
-                        setAddCoachRows(reordered.map((r, idx) => ({ ...r, positionNumber: idx + 1 })));
+                        setAddCoachRows(
+                          reordered.map((r, idx) => ({
+                            ...r,
+                            positionNumber: idx + 1,
+                          })),
+                        );
                       }}
                       className="flex gap-2 items-center p-2 bg-muted/50 rounded cursor-move hover:bg-muted transition-colors"
                     >
                       <GripVertical className="h-4 w-4 text-muted-foreground flex-shrink-0" />
-                      <span className="w-6 text-center text-xs text-muted-foreground flex-shrink-0">{row.positionNumber}</span>
-                      <select className="input input-sm flex-1" value={row.coachId}
-                        onChange={(e) => { const u = [...addCoachRows]; u[i] = { ...u[i], coachId: e.target.value }; setAddCoachRows(u); }}>
+                      <span className="w-6 text-center text-xs text-muted-foreground flex-shrink-0">
+                        {row.positionNumber}
+                      </span>
+                      <select
+                        className="input input-sm flex-1"
+                        value={row.coachId}
+                        onChange={(e) => {
+                          const u = [...addCoachRows];
+                          u[i] = { ...u[i], coachId: e.target.value };
+                          setAddCoachRows(u);
+                        }}
+                      >
                         <option value="">Select Coach</option>
-                        {coaches.filter((c: Coach) => !selectedIds.has(c.id) || c.id === row.coachId).map((c: Coach) => (
-                          <option key={c.id} value={c.id}>{c.number || c.coachNumber} — {c.coachType?.name} (Cap: {c.capacity})</option>
-                        ))}
+                        {coaches
+                          .filter(
+                            (c: Coach) =>
+                              !selectedIds.has(c.id) || c.id === row.coachId,
+                          )
+                          .map((c: Coach) => (
+                            <option key={c.id} value={c.id}>
+                              {c.number || c.coachNumber} — {c.coachType?.name}{" "}
+                              (Cap: {c.capacity})
+                            </option>
+                          ))}
                       </select>
-                      <button type="button" onClick={() => setAddCoachRows(addCoachRows.filter((_, idx) => idx !== i).map((r, idx) => ({ ...r, positionNumber: idx + 1 })))} className="p-1 text-destructive hover:bg-destructive/10 rounded flex-shrink-0">
+                      <button
+                        type="button"
+                        onClick={() =>
+                          setAddCoachRows(
+                            addCoachRows
+                              .filter((_, idx) => idx !== i)
+                              .map((r, idx) => ({
+                                ...r,
+                                positionNumber: idx + 1,
+                              })),
+                          )
+                        }
+                        className="p-1 text-destructive hover:bg-destructive/10 rounded flex-shrink-0"
+                      >
                         <X className="h-4 w-4" />
                       </button>
                     </div>
@@ -765,8 +1403,29 @@ export default function SchedulesPage() {
           </div>
 
           <div className="flex justify-end gap-2 pt-4">
-            <ActionButton type="button" variant="secondary" onClick={() => { setShowAddModal(false); setAddForm({ trainId: '', routeId: '', departureAt: '', arrivalAt: '' }); setAddCoachRows([]); setError(null); }}>Cancel</ActionButton>
-            <ActionButton type="submit" loading={createScheduleMutation.isPending}>Create Schedule</ActionButton>
+            <ActionButton
+              type="button"
+              variant="secondary"
+              onClick={() => {
+                setShowAddModal(false);
+                setAddForm({
+                  trainId: "",
+                  routeId: "",
+                  departureAt: "",
+                  arrivalAt: "",
+                });
+                setAddCoachRows([]);
+                setError(null);
+              }}
+            >
+              Cancel
+            </ActionButton>
+            <ActionButton
+              type="submit"
+              loading={createScheduleMutation.isPending}
+            >
+              Create Schedule
+            </ActionButton>
           </div>
         </form>
       </Modal>
@@ -777,12 +1436,12 @@ export default function SchedulesPage() {
           setShowModal(false);
           setError(null);
           setBulkForm({
-            trainId: '',
-            routeId: '',
-            startDateTime: '',
-            durationHours: '12',
-            repeatEveryDays: '1',
-            forNextDays: '30',
+            trainId: "",
+            routeId: "",
+            startDateTime: "",
+            durationHours: "12",
+            repeatEveryDays: "1",
+            forNextDays: "30",
           });
           setBulkCoachRows([]);
         }}
@@ -801,7 +1460,9 @@ export default function SchedulesPage() {
               <label className="label">Train *</label>
               <select
                 value={bulkForm.trainId}
-                onChange={(e) => setBulkForm({ ...bulkForm, trainId: e.target.value })}
+                onChange={(e) =>
+                  setBulkForm({ ...bulkForm, trainId: e.target.value })
+                }
                 className="input"
                 required
               >
@@ -818,7 +1479,9 @@ export default function SchedulesPage() {
               <label className="label">Route *</label>
               <select
                 value={bulkForm.routeId}
-                onChange={(e) => setBulkForm({ ...bulkForm, routeId: e.target.value })}
+                onChange={(e) =>
+                  setBulkForm({ ...bulkForm, routeId: e.target.value })
+                }
                 className="input"
                 required
               >
@@ -832,16 +1495,12 @@ export default function SchedulesPage() {
             </div>
           </div>
 
-          <div>
-            <label className="label">Departure Date & Time *</label>
-            <input
-              type="datetime-local"
-              value={bulkForm.startDateTime}
-              onChange={(e) => setBulkForm({ ...bulkForm, startDateTime: e.target.value })}
-              className="input"
-              required
-            />
-          </div>
+          <DateTimePicker
+            label="Departure Date & Time"
+            value={bulkForm.startDateTime}
+            onChange={(v) => setBulkForm({ ...bulkForm, startDateTime: v })}
+            required
+          />
 
           <div className="grid grid-cols-3 gap-4">
             <div>
@@ -850,7 +1509,9 @@ export default function SchedulesPage() {
                 type="number"
                 min="1"
                 placeholder={bulkForm.durationHours}
-                onChange={(e) => setBulkForm({ ...bulkForm, durationHours: e.target.value })}
+                onChange={(e) =>
+                  setBulkForm({ ...bulkForm, durationHours: e.target.value })
+                }
                 className="input"
               />
             </div>
@@ -861,7 +1522,9 @@ export default function SchedulesPage() {
                 type="number"
                 min="1"
                 placeholder={bulkForm.repeatEveryDays}
-                onChange={(e) => setBulkForm({ ...bulkForm, repeatEveryDays: e.target.value })}
+                onChange={(e) =>
+                  setBulkForm({ ...bulkForm, repeatEveryDays: e.target.value })
+                }
                 className="input"
               />
             </div>
@@ -872,7 +1535,9 @@ export default function SchedulesPage() {
                 type="number"
                 min="1"
                 placeholder={bulkForm.forNextDays}
-                onChange={(e) => setBulkForm({ ...bulkForm, forNextDays: e.target.value })}
+                onChange={(e) =>
+                  setBulkForm({ ...bulkForm, forNextDays: e.target.value })
+                }
                 className="input"
               />
             </div>
@@ -883,70 +1548,127 @@ export default function SchedulesPage() {
               <label className="label mb-0">Coaches</label>
               <div className="flex items-center gap-3">
                 {templateLoading && bulkForm.routeId && (
-                  <span className="text-xs text-muted-foreground flex items-center gap-1"><Loader2 className="h-3 w-3 animate-spin" /> Loading template…</span>
+                  <span className="text-xs text-muted-foreground flex items-center gap-1">
+                    <Loader2 className="h-3 w-3 animate-spin" /> Loading
+                    template…
+                  </span>
                 )}
                 {!bulkForm.routeId && (
-                  <span className="text-xs text-muted-foreground">Select a route to load its coach template</span>
+                  <span className="text-xs text-muted-foreground">
+                    Select a route to load its coach template
+                  </span>
                 )}
-                <ActionButton type="button" variant="secondary" size="sm" icon={Plus}
-                  disabled={bulkCoachRows.filter(r => r.coachId).length >= coaches.length}
-                  onClick={() => setBulkCoachRows([...bulkCoachRows, { coachId: '', positionNumber: bulkCoachRows.length + 1 }])}>
+                <ActionButton
+                  type="button"
+                  variant="secondary"
+                  size="sm"
+                  icon={Plus}
+                  disabled={
+                    bulkCoachRows.filter((r) => r.coachId).length >=
+                    coaches.length
+                  }
+                  onClick={() =>
+                    setBulkCoachRows([
+                      ...bulkCoachRows,
+                      { coachId: "", positionNumber: bulkCoachRows.length + 1 },
+                    ])
+                  }
+                >
                   Add Coach
                 </ActionButton>
               </div>
             </div>
 
             {bulkCoachRows.length === 0 ? (
-              <p className="text-sm text-muted-foreground py-2">No coaches assigned — schedules will be created without coach assignments.</p>
+              <p className="text-sm text-muted-foreground py-2">
+                No coaches assigned — schedules will be created without coach
+                assignments.
+              </p>
             ) : (
               <div className="space-y-2">
                 {bulkCoachRows.length > 1 && (
-                  <p className="text-xs text-muted-foreground">Drag <GripVertical className="inline h-3 w-3" /> to reorder</p>
+                  <p className="text-xs text-muted-foreground">
+                    Drag <GripVertical className="inline h-3 w-3" /> to reorder
+                  </p>
                 )}
                 {bulkCoachRows.map((row, i) => {
-                  const selectedIds = new Set(bulkCoachRows.map((r) => r.coachId).filter(Boolean));
+                  const selectedIds = new Set(
+                    bulkCoachRows.map((r) => r.coachId).filter(Boolean),
+                  );
                   return (
                     <div
                       key={i}
                       draggable
-                      onDragStart={(e) => e.dataTransfer.setData('bulk-coach-idx', i.toString())}
-                      onDragOver={(e) => { e.preventDefault(); (e.currentTarget as HTMLElement).style.opacity = '0.5'; }}
-                      onDragLeave={(e) => { (e.currentTarget as HTMLElement).style.opacity = '1'; }}
+                      onDragStart={(e) =>
+                        e.dataTransfer.setData("bulk-coach-idx", i.toString())
+                      }
+                      onDragOver={(e) => {
+                        e.preventDefault();
+                        (e.currentTarget as HTMLElement).style.opacity = "0.5";
+                      }}
+                      onDragLeave={(e) => {
+                        (e.currentTarget as HTMLElement).style.opacity = "1";
+                      }}
                       onDrop={(e) => {
                         e.preventDefault();
-                        (e.currentTarget as HTMLElement).style.opacity = '1';
-                        const src = parseInt(e.dataTransfer.getData('bulk-coach-idx'));
+                        (e.currentTarget as HTMLElement).style.opacity = "1";
+                        const src = parseInt(
+                          e.dataTransfer.getData("bulk-coach-idx"),
+                        );
                         if (src === i) return;
                         const reordered = [...bulkCoachRows];
                         const [moved] = reordered.splice(src, 1);
                         reordered.splice(i, 0, moved);
-                        setBulkCoachRows(reordered.map((r, idx) => ({ ...r, positionNumber: idx + 1 })));
+                        setBulkCoachRows(
+                          reordered.map((r, idx) => ({
+                            ...r,
+                            positionNumber: idx + 1,
+                          })),
+                        );
                       }}
                       className="flex gap-2 items-center p-2 bg-muted/50 rounded cursor-move hover:bg-muted transition-colors"
                     >
                       <GripVertical className="h-4 w-4 text-muted-foreground flex-shrink-0" />
-                      <span className="w-6 text-center text-xs text-muted-foreground flex-shrink-0">{row.positionNumber}</span>
+                      <span className="w-6 text-center text-xs text-muted-foreground flex-shrink-0">
+                        {row.positionNumber}
+                      </span>
                       <select
                         className="input input-sm flex-1"
                         value={row.coachId}
                         onChange={(e) => {
                           const updated = [...bulkCoachRows];
-                          updated[i] = { ...updated[i], coachId: e.target.value };
+                          updated[i] = {
+                            ...updated[i],
+                            coachId: e.target.value,
+                          };
                           setBulkCoachRows(updated);
                         }}
                       >
                         <option value="">Select Coach</option>
                         {coaches
-                          .filter((c: Coach) => !selectedIds.has(c.id) || c.id === row.coachId)
+                          .filter(
+                            (c: Coach) =>
+                              !selectedIds.has(c.id) || c.id === row.coachId,
+                          )
                           .map((c: Coach) => (
                             <option key={c.id} value={c.id}>
-                              {c.number || c.coachNumber} — {c.coachType?.name} (Cap: {c.capacity})
+                              {c.number || c.coachNumber} — {c.coachType?.name}{" "}
+                              (Cap: {c.capacity})
                             </option>
                           ))}
                       </select>
                       <button
                         type="button"
-                        onClick={() => setBulkCoachRows(bulkCoachRows.filter((_, idx) => idx !== i).map((r, idx) => ({ ...r, positionNumber: idx + 1 })))}
+                        onClick={() =>
+                          setBulkCoachRows(
+                            bulkCoachRows
+                              .filter((_, idx) => idx !== i)
+                              .map((r, idx) => ({
+                                ...r,
+                                positionNumber: idx + 1,
+                              })),
+                          )
+                        }
                         className="p-1 text-destructive hover:bg-destructive/10 rounded flex-shrink-0"
                       >
                         <X className="h-4 w-4" />
@@ -960,15 +1682,24 @@ export default function SchedulesPage() {
 
           <div className="bg-blue-50 p-4 rounded-lg">
             <p className="text-sm text-blue-900">
-              <strong>Preview:</strong> Will create approximately{' '}
-              <strong>{Math.ceil(parseInt(bulkForm.forNextDays) / parseInt(bulkForm.repeatEveryDays))}</strong>{' '}
-              schedules, starting from the specified date, repeating every{' '}
-              <strong>{bulkForm.repeatEveryDays}</strong> days for the next{' '}
+              <strong>Preview:</strong> Will create approximately{" "}
+              <strong>
+                {Math.ceil(
+                  parseInt(bulkForm.forNextDays) /
+                    parseInt(bulkForm.repeatEveryDays),
+                )}
+              </strong>{" "}
+              schedules, starting from the specified date, repeating every{" "}
+              <strong>{bulkForm.repeatEveryDays}</strong> days for the next{" "}
               <strong>{bulkForm.forNextDays}</strong> days.
-              {bulkCoachRows.filter(r => r.coachId).length > 0 && (
+              {bulkCoachRows.filter((r) => r.coachId).length > 0 && (
                 <>
-                  {' '}
-                  Each schedule will have <strong>{bulkCoachRows.filter(r => r.coachId).length}</strong> coach(es) assigned.
+                  {" "}
+                  Each schedule will have{" "}
+                  <strong>
+                    {bulkCoachRows.filter((r) => r.coachId).length}
+                  </strong>{" "}
+                  coach(es) assigned.
                 </>
               )}
             </p>
@@ -982,19 +1713,22 @@ export default function SchedulesPage() {
                 setShowModal(false);
                 setError(null);
                 setBulkForm({
-                  trainId: '',
-                  routeId: '',
-                  startDateTime: '',
-                  durationHours: '12',
-                  repeatEveryDays: '1',
-                  forNextDays: '30',
+                  trainId: "",
+                  routeId: "",
+                  startDateTime: "",
+                  durationHours: "12",
+                  repeatEveryDays: "1",
+                  forNextDays: "30",
                 });
                 setBulkCoachRows([]);
               }}
             >
               Cancel
             </ActionButton>
-            <ActionButton type="submit" loading={bulkGenerateMutation.isPending}>
+            <ActionButton
+              type="submit"
+              loading={bulkGenerateMutation.isPending}
+            >
               Generate Schedules
             </ActionButton>
           </div>
@@ -1006,9 +1740,10 @@ export default function SchedulesPage() {
         onClose={() => {
           setShowEditModal(false);
           setEditingSchedule(null);
+          setEditStopTimes([]);
           setError(null);
         }}
-        title={`Edit Schedule: ${editingSchedule?.originStation?.name ?? ''} → ${editingSchedule?.destinationStation?.name ?? ''}`}
+        title={`Edit Schedule: ${editingSchedule?.originStation?.name ?? ""} → ${editingSchedule?.destinationStation?.name ?? ""}`}
         size="lg"
       >
         {editingSchedule && (
@@ -1022,23 +1757,19 @@ export default function SchedulesPage() {
             <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
               <div>
                 <label className="label">Departure Date & Time *</label>
-                <input
-                  type="datetime-local"
+                <DateTimePicker
                   value={editForm.departureAt}
-                  onChange={(e) => setEditForm({ ...editForm, departureAt: e.target.value })}
-                  className="input"
-                  required
+                  onChange={(v) => setEditForm({ ...editForm, departureAt: v })}
+                  placeholder="Select departure"
                 />
               </div>
 
               <div>
                 <label className="label">Arrival Date & Time *</label>
-                <input
-                  type="datetime-local"
+                <DateTimePicker
                   value={editForm.arrivalAt}
-                  onChange={(e) => setEditForm({ ...editForm, arrivalAt: e.target.value })}
-                  className="input"
-                  required
+                  onChange={(v) => setEditForm({ ...editForm, arrivalAt: v })}
+                  placeholder="Select arrival"
                 />
               </div>
             </div>
@@ -1047,7 +1778,9 @@ export default function SchedulesPage() {
               <label className="label">Status</label>
               <select
                 value={editForm.status}
-                onChange={(e) => setEditForm({ ...editForm, status: e.target.value })}
+                onChange={(e) =>
+                  setEditForm({ ...editForm, status: e.target.value })
+                }
                 className="input"
               >
                 <option value="SCHEDULED">Scheduled</option>
@@ -1063,15 +1796,145 @@ export default function SchedulesPage() {
                 type="checkbox"
                 id="isPackageOnly"
                 checked={editForm.isPackageOnly}
-                onChange={(e) => setEditForm({ ...editForm, isPackageOnly: e.target.checked })}
+                onChange={(e) =>
+                  setEditForm({ ...editForm, isPackageOnly: e.target.checked })
+                }
                 className="w-4 h-4 rounded"
               />
               <label htmlFor="isPackageOnly" className="text-sm cursor-pointer">
                 <span className="font-medium">Package Only</span>
-                <span className="block text-xs text-muted-foreground">Hide from public search — reserved for package bookings</span>
+                <span className="block text-xs text-muted-foreground">
+                  Hide from public search — reserved for package bookings
+                </span>
               </label>
             </div>
 
+            {editStopTimes.length > 0 && (
+              <div className="border-t pt-4">
+                <div className="flex items-center justify-between mb-3">
+                  <div>
+                    <label className="label mb-0">Stop Times</label>
+                    <p className="text-xs text-muted-foreground mt-0.5">
+                      Edit planned times for each stop. All stops must be filled
+                      to update.
+                    </p>
+                  </div>
+                  <button
+                    type="button"
+                    className="text-xs text-primary underline"
+                    onClick={() => {
+                      const dep = editForm.departureAt
+                        ? new Date(editForm.departureAt + ":00Z")
+                        : null;
+                      const arr = editForm.arrivalAt
+                        ? new Date(editForm.arrivalAt + ":00Z")
+                        : null;
+                      if (!dep || !arr || arr <= dep) return;
+                      const stops = (editRouteDetail as any)?.stops ?? [];
+                      const totalDuration = arr.getTime() - dep.getTime();
+                      const totalDistance =
+                        stops[stops.length - 1]?.distanceKm || 1;
+                      setEditStopTimes(
+                        editStopTimes.map((s, i) => {
+                          const stop = stops.find(
+                            (st: any) => st.sequence === s.sequence,
+                          );
+                          const dist =
+                            stops.length > 0 ? (stop?.distanceKm ?? 0) : 0;
+                          const progress =
+                            stops.length > 0 && totalDistance > 0
+                              ? dist / totalDistance
+                              : i / Math.max(editStopTimes.length - 1, 1);
+                          const t = new Date(
+                            dep.getTime() + totalDuration * progress,
+                          );
+                          const fmt = t.toISOString().slice(0, 16);
+                          return {
+                            ...s,
+                            plannedArrivalAt: i === 0 ? "" : fmt,
+                            plannedDepartureAt:
+                              i === editStopTimes.length - 1 ? "" : fmt,
+                          };
+                        }),
+                      );
+                    }}
+                  >
+                    Auto-fill from departure/arrival
+                  </button>
+                </div>
+                <div className="overflow-x-auto">
+                  <table className="w-full text-sm">
+                    <thead>
+                      <tr className="text-left text-xs text-muted-foreground border-b">
+                        <th className="pb-2 pr-3 font-medium">#</th>
+                        <th className="pb-2 pr-3 font-medium">Station</th>
+                        <th className="pb-2 pr-3 font-medium">
+                          Planned Arrival
+                        </th>
+                        <th className="pb-2 font-medium">Planned Departure</th>
+                      </tr>
+                    </thead>
+                    <tbody className="divide-y">
+                      {editStopTimes.map((stop, i) => {
+                        const isFirst = i === 0;
+                        const isLast = i === editStopTimes.length - 1;
+                        return (
+                          <tr key={stop.sequence}>
+                            <td className="py-2 pr-3 text-muted-foreground">
+                              {stop.sequence}
+                            </td>
+                            <td className="py-2 pr-3 font-medium whitespace-nowrap">
+                              {stop.stationName}
+                            </td>
+                            <td className="py-2 pr-3 min-w-[200px]">
+                              {isFirst ? (
+                                <span className="text-xs text-muted-foreground italic">
+                                  —
+                                </span>
+                              ) : (
+                                <DateTimePicker
+                                  value={stop.plannedArrivalAt}
+                                  onChange={(v) => {
+                                    const updated = [...editStopTimes];
+                                    updated[i] = {
+                                      ...updated[i],
+                                      plannedArrivalAt: v,
+                                    };
+                                    setEditStopTimes(updated);
+                                  }}
+                                  placeholder="Pick arrival"
+                                />
+                              )}
+                            </td>
+                            <td className="py-2 min-w-[200px]">
+                              {isLast ? (
+                                <span className="text-xs text-muted-foreground italic">
+                                  —
+                                </span>
+                              ) : (
+                                <DateTimePicker
+                                  value={stop.plannedDepartureAt}
+                                  onChange={(v) => {
+                                    const updated = [...editStopTimes];
+                                    updated[i] = {
+                                      ...updated[i],
+                                      plannedDepartureAt: v,
+                                    };
+                                    setEditStopTimes(updated);
+                                  }}
+                                  placeholder="Pick departure"
+                                />
+                              )}
+                            </td>
+                          </tr>
+                        );
+                      })}
+                    </tbody>
+                  </table>
+                </div>
+              </div>
+            )}
+
             <div>
               <div className="flex items-center justify-between mb-2">
                 <label className="label">Coaches (Optional)</label>
@@ -1081,20 +1944,30 @@ export default function SchedulesPage() {
                     if (editForm.coachIds.length === coaches.length) {
                       setEditForm({ ...editForm, coachIds: [] });
                     } else {
-                      setEditForm({ ...editForm, coachIds: coaches.map((c: Coach) => c.id) });
+                      setEditForm({
+                        ...editForm,
+                        coachIds: coaches.map((c: Coach) => c.id),
+                      });
                     }
                   }}
                   className="text-xs text-primary hover:underline"
                 >
-                  {editForm.coachIds.length === coaches.length ? 'Deselect All' : 'Select All'}
+                  {editForm.coachIds.length === coaches.length
+                    ? "Deselect All"
+                    : "Select All"}
                 </button>
               </div>
               <div className="border border-border rounded-lg p-3 max-h-64 overflow-y-auto space-y-2">
                 {coaches.length === 0 ? (
-                  <p className="text-sm text-muted-foreground">No coaches available</p>
+                  <p className="text-sm text-muted-foreground">
+                    No coaches available
+                  </p>
                 ) : (
                   coaches.map((coach: Coach) => (
-                    <label key={coach.id} className="flex items-center gap-2 cursor-pointer">
+                    <label
+                      key={coach.id}
+                      className="flex items-center gap-2 cursor-pointer"
+                    >
                       <input
                         type="checkbox"
                         checked={editForm.coachIds.includes(coach.id)}
@@ -1107,14 +1980,18 @@ export default function SchedulesPage() {
                           } else {
                             setEditForm({
                               ...editForm,
-                              coachIds: editForm.coachIds.filter((id) => id !== coach.id),
+                              coachIds: editForm.coachIds.filter(
+                                (id) => id !== coach.id,
+                              ),
                             });
                           }
                         }}
                         className="rounded"
                       />
                       <span className="text-sm">
-                        {coach.sequence || 'N/A'} - {coach.number || coach.coachNumber} - {coach.coachType?.name} (Cap: {coach.capacity})
+                        {coach.sequence || "N/A"} -{" "}
+                        {coach.number || coach.coachNumber} -{" "}
+                        {coach.coachType?.name} (Cap: {coach.capacity})
                       </span>
                     </label>
                   ))
@@ -1129,12 +2006,16 @@ export default function SchedulesPage() {
                 onClick={() => {
                   setShowEditModal(false);
                   setEditingSchedule(null);
+                  setEditStopTimes([]);
                   setError(null);
                 }}
               >
                 Cancel
               </ActionButton>
-              <ActionButton type="submit" loading={updateScheduleMutation.isPending}>
+              <ActionButton
+                type="submit"
+                loading={updateScheduleMutation.isPending}
+              >
                 Update Schedule
               </ActionButton>
             </div>
diff --git a/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
index 00e594601..9d5c62414 100644
--- a/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
+++ b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
@@ -80,13 +80,13 @@ const navigationSections: { title: string; items: NavItem[] }[] = [
   {
     title: 'Master Data',
     items: [
-      { name: 'Stations',   href: '/stations',   icon: MapPin,    permission: PERMS.stations.view },
-      { name: 'Trains',     href: '/trains',     icon: Train,     permission: PERMS.trains.view },
-      { name: 'Coaches',    href: '/coaches',    icon: Grid3x3,   permission: PERMS.coaches.view },
-      { name: 'Seats',      href: '/seats',      icon: Armchair,  permission: PERMS.seats.view },
-      { name: 'Classes',    href: '/classes',    icon: Settings,  permission: PERMS.classes.view },
-      { name: 'Routes',     href: '/routes',     icon: Route,     permission: PERMS.routes.view },
-      { name: 'Schedules',  href: '/schedules',  icon: Calendar,  permission: PERMS.schedules.view },
+      { name: 'Stations',   href: '/stations',   icon: MapPin },
+      { name: 'Trains',     href: '/trains',     icon: Train },
+      { name: 'Coaches',    href: '/coaches',    icon: Grid3x3 },
+      { name: 'Seats',      href: '/seats',      icon: Armchair },
+      { name: 'Classes',    href: '/classes',    icon: Settings },
+      { name: 'Routes',     href: '/routes',     icon: Route },
+      { name: 'Schedules',  href: '/schedules',  icon: Calendar },
     ]
   },
   {
diff --git a/apps/edr-passenger-web/backoffice/src/components/ui/DateTimePicker.tsx b/apps/edr-passenger-web/backoffice/src/components/ui/DateTimePicker.tsx
new file mode 100644
index 000000000..6e71fc268
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/components/ui/DateTimePicker.tsx
@@ -0,0 +1,358 @@
+'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+import { createPortal } from 'react-dom';
+import { DayPicker } from 'react-day-picker';
+import { ChevronLeft, ChevronRight, Calendar, ChevronUp, ChevronDown, X } from 'lucide-react';
+import { cn } from '@/lib/utils';
+
+interface DateTimePickerProps {
+  value: string; // YYYY-MM-DDTHH:mm (datetime-local format)
+  onChange: (value: string) => void;
+  required?: boolean;
+  id?: string;
+  placeholder?: string;
+  label?: string;
+}
+
+function parseLocalString(s: string) {
+  if (!s) return null;
+  const [datePart, timePart] = s.split('T');
+  if (!datePart || !timePart) return null;
+  const [yyyy, mm, dd] = datePart.split('-').map(Number);
+  const [h, m] = timePart.split(':').map(Number);
+  if (isNaN(yyyy) || isNaN(mm) || isNaN(dd) || isNaN(h) || isNaN(m)) return null;
+  const period: 'AM' | 'PM' = h >= 12 ? 'PM' : 'AM';
+  const hours12 = h % 12 === 0 ? 12 : h % 12;
+  const date = new Date(yyyy, mm - 1, dd);
+  return { date, hours12, minutes: m, period };
+}
+
+function toLocalString(date: Date, hours12: number, minutes: number, period: 'AM' | 'PM') {
+  let h = hours12 % 12;
+  if (period === 'PM') h += 12;
+  const yyyy = date.getFullYear();
+  const mm = String(date.getMonth() + 1).padStart(2, '0');
+  const dd = String(date.getDate()).padStart(2, '0');
+  const hh = String(h).padStart(2, '0');
+  const min = String(minutes).padStart(2, '0');
+  return `${yyyy}-${mm}-${dd}T${hh}:${min}`;
+}
+
+function formatDisplay(parsed: ReturnType<typeof parseLocalString>): string {
+  if (!parsed) return '';
+  const { date, hours12, minutes, period } = parsed;
+  const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+  const dateStr = `${months[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()}`;
+  const timeStr = `${String(hours12).padStart(2, '0')}:${String(minutes).padStart(2, '0')} ${period}`;
+  return `${dateStr}  ${timeStr}`;
+}
+
+export default function DateTimePicker({
+  value,
+  onChange,
+  id,
+  placeholder = 'Select date & time',
+  label,
+}: DateTimePickerProps) {
+  const [open, setOpen] = useState(false);
+  const [mounted, setMounted] = useState(false);
+
+  useEffect(() => { setMounted(true); }, []);
+
+  const parsed = parseLocalString(value);
+  const [selectedDate, setSelectedDate] = useState<Date | undefined>(parsed?.date);
+  const [hours12, setHours12] = useState<number>(parsed?.hours12 ?? 12);
+  const [minutes, setMinutes] = useState<number>(parsed?.minutes ?? 0);
+  const [period, setPeriod] = useState<'AM' | 'PM'>(parsed?.period ?? 'AM');
+
+  // Sync internal state when value changes externally
+  useEffect(() => {
+    const p = parseLocalString(value);
+    if (p) {
+      setSelectedDate(p.date);
+      setHours12(p.hours12);
+      setMinutes(p.minutes);
+      setPeriod(p.period);
+    }
+  }, [value]);
+
+  // Close on Escape
+  useEffect(() => {
+    if (!open) return;
+    const handler = (e: KeyboardEvent) => { if (e.key === 'Escape') setOpen(false); };
+    document.addEventListener('keydown', handler);
+    return () => document.removeEventListener('keydown', handler);
+  }, [open]);
+
+  const emit = useCallback(
+    (date: Date | undefined, h: number, m: number, p: 'AM' | 'PM') => {
+      if (!date) return;
+      onChange(toLocalString(date, h, m, p));
+    },
+    [onChange],
+  );
+
+  const handleDaySelect = (date: Date | undefined) => {
+    setSelectedDate(date);
+    if (date) emit(date, hours12, minutes, period);
+  };
+
+  const cycleHour = (dir: 1 | -1) => {
+    const next = hours12 + dir;
+    const h = next > 12 ? 1 : next < 1 ? 12 : next;
+    setHours12(h);
+    emit(selectedDate, h, minutes, period);
+  };
+
+  const cycleMinute = (dir: 1 | -1) => {
+    const next = minutes + dir;
+    const m = next > 59 ? 0 : next < 0 ? 59 : next;
+    setMinutes(m);
+    emit(selectedDate, hours12, m, period);
+  };
+
+  const togglePeriod = (p: 'AM' | 'PM') => {
+    setPeriod(p);
+    emit(selectedDate, hours12, minutes, p);
+  };
+
+  const handleHourInput = (raw: string) => {
+    const h = parseInt(raw);
+    if (isNaN(h)) return;
+    const clamped = Math.max(1, Math.min(12, h));
+    setHours12(clamped);
+    emit(selectedDate, clamped, minutes, period);
+  };
+
+  const handleMinuteInput = (raw: string) => {
+    const m = parseInt(raw);
+    if (isNaN(m)) return;
+    const clamped = Math.max(0, Math.min(59, m));
+    setMinutes(clamped);
+    emit(selectedDate, hours12, clamped, period);
+  };
+
+  const modal = open && mounted ? createPortal(
+    <div
+      className="fixed inset-0 flex items-center justify-center p-4"
+      style={{ zIndex: 10050 }}
+    >
+      {/* Backdrop */}
+      <div
+        className="fixed inset-0 bg-black/60 backdrop-blur-sm"
+        onClick={() => setOpen(false)}
+      />
+
+      {/* Panel */}
+      <div className="relative bg-background border border-border rounded-2xl shadow-2xl p-5 w-80 animate-fade-up">
+        {/* Header */}
+        <div className="flex items-center justify-between mb-4">
+          <h3 className="text-sm font-semibold text-foreground">
+            {label ?? placeholder}
+          </h3>
+          <button
+            type="button"
+            onClick={() => setOpen(false)}
+            className="h-7 w-7 flex items-center justify-center rounded-lg text-muted-foreground hover:text-foreground hover:bg-muted transition-colors"
+          >
+            <X className="h-4 w-4" />
+          </button>
+        </div>
+
+        {/* Calendar */}
+        <DayPicker
+          mode="single"
+          selected={selectedDate}
+          onSelect={handleDaySelect}
+          showOutsideDays
+          classNames={{
+            root: 'w-full',
+            months: 'w-full',
+            month: 'w-full',
+            month_caption: 'flex items-center justify-between mb-3',
+            caption_label: 'text-sm font-semibold text-foreground',
+            nav: 'flex items-center gap-1',
+            button_previous: [
+              'h-7 w-7 rounded-lg flex items-center justify-center',
+              'text-muted-foreground hover:text-foreground hover:bg-muted transition-colors',
+            ].join(' '),
+            button_next: [
+              'h-7 w-7 rounded-lg flex items-center justify-center',
+              'text-muted-foreground hover:text-foreground hover:bg-muted transition-colors',
+            ].join(' '),
+            month_grid: 'w-full border-collapse',
+            weekdays: 'flex w-full mb-1',
+            weekday: 'flex-1 text-center text-xs font-medium text-muted-foreground py-1',
+            weeks: '',
+            week: 'flex w-full mt-0.5',
+            day: 'flex-1 flex items-center justify-center p-0',
+            day_button: [
+              'h-8 w-8 text-xs rounded-lg flex items-center justify-center',
+              'transition-colors hover:bg-muted cursor-pointer',
+            ].join(' '),
+            selected: '',
+            today: '',
+            outside: 'opacity-30',
+            disabled: 'opacity-20 cursor-not-allowed',
+            hidden: 'invisible',
+            range_start: '',
+            range_end: '',
+            range_middle: '',
+            focused: 'ring-1 ring-primary/50',
+            chevron: '',
+            dropdowns: '',
+            dropdown: '',
+            dropdown_root: '',
+            footer: '',
+            months_dropdown: '',
+            week_number: '',
+            week_number_header: '',
+            years_dropdown: '',
+            weeks_after_enter: '',
+            weeks_after_exit: '',
+            weeks_before_enter: '',
+            weeks_before_exit: '',
+          }}
+          components={{
+            Chevron: ({ orientation }) =>
+              orientation === 'left' ? (
+                <ChevronLeft className="h-4 w-4" />
+              ) : (
+                <ChevronRight className="h-4 w-4" />
+              ),
+            DayButton: ({ day, modifiers, className, ...props }) => (
+              <button
+                {...props}
+                className={cn(
+                  className,
+                  modifiers.selected && 'bg-primary text-primary-foreground font-semibold',
+                  modifiers.today && !modifiers.selected && 'text-primary font-bold',
+                )}
+              />
+            ),
+          }}
+        />
+
+        {/* Time picker */}
+        <div className="mt-3 pt-3 border-t border-border">
+          <p className="text-xs font-medium text-muted-foreground mb-3">Time</p>
+          <div className="flex items-center gap-3">
+
+            {/* Hour spinner */}
+            <div className="flex flex-col items-center gap-0.5">
+              <button
+                type="button"
+                onClick={() => cycleHour(-1)}
+                className="h-6 w-10 flex items-center justify-center rounded hover:bg-muted text-muted-foreground transition-colors"
+              >
+                <ChevronUp className="h-3.5 w-3.5" />
+              </button>
+              <input
+                type="text"
+                inputMode="numeric"
+                value={String(hours12).padStart(2, '0')}
+                onChange={e => handleHourInput(e.target.value)}
+                onFocus={e => e.target.select()}
+                className="w-10 text-center text-base font-mono border border-border rounded-lg py-1.5 bg-background focus:outline-none focus:border-primary focus:ring-2 focus:ring-primary/20"
+              />
+              <button
+                type="button"
+                onClick={() => cycleHour(1)}
+                className="h-6 w-10 flex items-center justify-center rounded hover:bg-muted text-muted-foreground transition-colors"
+              >
+                <ChevronDown className="h-3.5 w-3.5" />
+              </button>
+            </div>
+
+            <span className="text-2xl font-bold text-foreground leading-none mb-0.5">:</span>
+
+            {/* Minute spinner */}
+            <div className="flex flex-col items-center gap-0.5">
+              <button
+                type="button"
+                onClick={() => cycleMinute(-1)}
+                className="h-6 w-10 flex items-center justify-center rounded hover:bg-muted text-muted-foreground transition-colors"
+              >
+                <ChevronUp className="h-3.5 w-3.5" />
+              </button>
+              <input
+                type="text"
+                inputMode="numeric"
+                value={String(minutes).padStart(2, '0')}
+                onChange={e => handleMinuteInput(e.target.value)}
+                onFocus={e => e.target.select()}
+                className="w-10 text-center text-base font-mono border border-border rounded-lg py-1.5 bg-background focus:outline-none focus:border-primary focus:ring-2 focus:ring-primary/20"
+              />
+              <button
+                type="button"
+                onClick={() => cycleMinute(1)}
+                className="h-6 w-10 flex items-center justify-center rounded hover:bg-muted text-muted-foreground transition-colors"
+              >
+                <ChevronDown className="h-3.5 w-3.5" />
+              </button>
+            </div>
+
+            {/* AM / PM */}
+            <div className="flex flex-col gap-1.5 ml-auto">
+              <button
+                type="button"
+                onClick={() => togglePeriod('AM')}
+                className={cn(
+                  'px-4 py-1.5 text-sm font-semibold rounded-lg border transition-colors',
+                  period === 'AM'
+                    ? 'bg-primary text-primary-foreground border-primary'
+                    : 'bg-background text-muted-foreground border-border hover:bg-muted',
+                )}
+              >
+                AM
+              </button>
+              <button
+                type="button"
+                onClick={() => togglePeriod('PM')}
+                className={cn(
+                  'px-4 py-1.5 text-sm font-semibold rounded-lg border transition-colors',
+                  period === 'PM'
+                    ? 'bg-primary text-primary-foreground border-primary'
+                    : 'bg-background text-muted-foreground border-border hover:bg-muted',
+                )}
+              >
+                PM
+              </button>
+            </div>
+          </div>
+        </div>
+
+        {/* Confirm */}
+        <button
+          type="button"
+          onClick={() => setOpen(false)}
+          className="mt-4 w-full btn btn-primary text-sm py-2"
+        >
+          Confirm
+        </button>
+      </div>
+    </div>,
+    document.body,
+  ) : null;
+
+  const displayText = parsed ? formatDisplay(parsed) : placeholder;
+
+  return (
+    <div className="relative">
+      <button
+        type="button"
+        id={id}
+        onClick={() => setOpen(true)}
+        className={cn(
+          'input flex items-center gap-2 text-left cursor-pointer',
+          !parsed && 'text-muted-foreground',
+        )}
+      >
+        <Calendar className="h-4 w-4 text-muted-foreground shrink-0" />
+        <span className="flex-1 text-sm">{displayText}</span>
+      </button>
+      {modal}
+    </div>
+  );
+}
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 2453eafa2..1b917afe2 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
@@ -151,6 +151,7 @@ export const seatsApi = {
     return apiClient.get<any>(`/seats/seatmap/${scheduleId}${params}`);
   },
   getBySchedule: (scheduleId: string) => apiClient.get<any>(`/seats/schedule/${scheduleId}`),
+  getBlocked: () => apiClient.get<any[]>('/seats/blocks'),
   hold: (data: any) => apiClient.post<any>('/seats/hold', data),
   release: (holdId: string) => apiClient.delete(`/seats/hold/${holdId}`),
   block: (seatId: string, data: any) => apiClient.post<any>(`/seats/${seatId}/block`, data),
diff --git a/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
index 7d9cd691a..1039b1465 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/confirmation/page.tsx
@@ -263,21 +263,24 @@ export default function ConfirmationPage() {
         const ticketNumber = matchedTicket?.barcodePayload || "Not yet issued";
 
         await generatePassengerVoucherPDF({
-          bookingRef: pnr,
+          bookingRef:          pnr,
           ticketNumber,
-          passengerName: p.name || `Passenger ${i + 1}`,
-          dateOfBirth: p.dateOfBirth,
-          nationality: p.nationality,
-          seatNumber: p.seatNumber,
-          outboundSeatNumber: (p as any).outboundSeatNumber,
-          inboundSeatNumber: (p as any).inboundSeatNumber,
+          passengerName:       p.name || `Passenger ${i + 1}`,
+          dateOfBirth:         p.dateOfBirth,
+          nationality:         p.nationality,
+          seatNumber:          p.seatNumber,
+          coachNumber:         p.coachNumber,
+          outboundSeatNumber:  p.outboundSeatNumber,
+          outboundCoachNumber: p.outboundCoachNumber,
+          inboundSeatNumber:   p.inboundSeatNumber,
+          inboundCoachNumber:  p.inboundCoachNumber,
           status,
-          outboundSchedule: outbound,
-          inboundSchedule: inbound,
+          outboundSchedule:    outbound,
+          inboundSchedule:     inbound,
           isRoundTrip,
-          fareMinor: hasSettledAmount ? settledAmountMinor! : getEtbFare(i),
-          currency: voucherCurrency,
-          fareIsMajorUnits: hasSettledAmount,
+          fareMinor:           hasSettledAmount ? settledAmountMinor! : getEtbFare(i),
+          currency:            voucherCurrency,
+          fareIsMajorUnits:    hasSettledAmount,
           createdAt,
         });
       }
diff --git a/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx
index 95d390182..0ec2599b7 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/review/page.tsx
@@ -190,13 +190,18 @@ const adultPassengerCount = searchCriteria?.adultCount ?? passengers.filter(p =>
       }
       return null;
     }
+    // One-way: seat-specific fare (set at seat selection) is the authoritative price —
+    // it is exactly what was shown to the user. Use the fare-breakdown API only as fallback
+    // for cases where seatFareMinor was not captured (e.g. auto-assign without seat map).
+    if (p.seatFareMinor != null) {
+      return isPackageBooking ? p.seatFareMinor * 2 : p.seatFareMinor;
+    }
     if (!isPackageBooking && fareBreakdown?.passengers && index != null) {
       const line = fareBreakdown.passengers[index];
       const displayFare = line?.displayFareMinor ?? line?.fareMinor;
       if (displayFare != null) return displayFare;
     }
-    if (p.seatFareMinor == null) return null;
-    return isPackageBooking ? p.seatFareMinor * 2 : p.seatFareMinor;
+    return null;
   };
 
   const createBookingMutation = useMutation({
diff --git a/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx b/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx
index 2c5123def..361090b25 100644
--- a/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/packages/[id]/page.tsx
@@ -603,11 +603,20 @@ export default function PackageDetailPage() {
         })),
       });
 
-      const outboundSched = toSchedule(ctx.outboundSchedule);
+      // booking-context returns flat originStationId/destinationStationId, not nested objects.
+      // Use the user's selected departure station as the true origin for both the
+      // search criteria and the schedule objects so hold/booking APIs get the right segment.
+      const outboundDestId = ctx.outboundSchedule.destinationStationId ?? ctx.outboundSchedule.destinationStation?.id ?? "";
+
+      const outboundSched = {
+        ...toSchedule(ctx.outboundSchedule),
+        originStationId: departureStationId,
+        origin: departureStationName,
+      };
 
       setSearchCriteria({
-        originStationId: ctx.outboundSchedule.originStation?.id ?? "",
-        destinationStationId: ctx.outboundSchedule.destinationStation?.id ?? "",
+        originStationId: departureStationId,
+        destinationStationId: outboundDestId,
         departureDate: ctx.outboundSchedule.departureAt?.slice(0, 10) ?? "",
         returnDate: ctx.returnSchedule?.departureAt?.slice(0, 10),
         tripType: isRoundTrip ? "ROUND_TRIP" : "ONE_WAY",
@@ -618,7 +627,11 @@ export default function PackageDetailPage() {
 
       if (isRoundTrip) {
         setOutboundSchedule(outboundSched);
-        setInboundSchedule(toSchedule(ctx.returnSchedule));
+        setInboundSchedule({
+          ...toSchedule(ctx.returnSchedule),
+          destinationStationId: departureStationId,
+          destination: departureStationName,
+        });
       } else {
         setSelectedSchedule(outboundSched);
       }
diff --git a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
index 894795c52..439c26c29 100644
--- a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
+++ b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
@@ -24,8 +24,11 @@ interface PassengerVoucherData {
   dateOfBirth?: string;
   nationality?: string;
   seatNumber?: string;
+  coachNumber?: string;
   outboundSeatNumber?: string;
+  outboundCoachNumber?: string;
   inboundSeatNumber?: string;
+  inboundCoachNumber?: string;
   status: string;
   outboundSchedule: ScheduleInfo;
   inboundSchedule?: ScheduleInfo;
@@ -314,16 +317,21 @@ function drawPassengerDetails(doc: jsPDF, data: PassengerVoucherData, y: number,
   label(doc, 'Passenger details', margin, y);
   y += 7;
 
+  const formatSeat = (coach: string | undefined, seat: string | undefined): string => {
+    if (!seat) return '—';
+    return coach ? `Coach ${coach}  ·  Seat ${seat}` : `Seat ${seat}`;
+  };
+
   const rows: [string, string][] = [
     ['Full name', data.passengerName || '—'],
     ['Date of birth', data.dateOfBirth ? new Date(data.dateOfBirth).toLocaleDateString('en-US', { year: 'numeric', month: 'long', day: 'numeric' }) : '—'],
     ['Nationality', data.nationality || '—'],
   ];
   if (data.isRoundTrip) {
-    rows.push(['Outbound seat', data.outboundSeatNumber || '—']);
-    rows.push(['Return seat', data.inboundSeatNumber || '—']);
+    rows.push(['Outbound seat', formatSeat(data.outboundCoachNumber, data.outboundSeatNumber)]);
+    rows.push(['Return seat', formatSeat(data.inboundCoachNumber, data.inboundSeatNumber)]);
   } else {
-    rows.push(['Seat', data.seatNumber || '—']);
+    rows.push(['Seat', formatSeat(data.coachNumber, data.seatNumber)]);
   }
 
   const rowH = 7;
@@ -485,9 +493,10 @@ export const generateVoucherPDF = async (booking: VoucherData): Promise<void> =>
   // Group leg rows back into one entry per real passenger — without this, a round trip
   // produced two half-passenger vouchers (one per leg, each showing only its own leg's
   // seat) instead of one voucher per passenger covering both legs.
+  type SeatInfo = VoucherData['passengers'][number]['seat'];
   const grouped = new Map<
     string,
-    { fullName: string; category: string; outboundSeat?: VoucherData['passengers'][number]['seat']; returnSeat?: VoucherData['passengers'][number]['seat'] }
+    { fullName: string; category: string; outboundSeat?: SeatInfo; returnSeat?: SeatInfo }
   >();
   booking.passengers.forEach((p) => {
     const key = `${p.fullName}|${p.dateOfBirth}|${p.category}`;
@@ -514,20 +523,23 @@ export const generateVoucherPDF = async (booking: VoucherData): Promise<void> =>
     const ticketNumber = matchedTicket?.barcodePayload || 'Not yet issued';
 
     await generatePassengerVoucherPDF({
-      bookingRef:          booking.bookingRef,
+      bookingRef:           booking.bookingRef,
       ticketNumber,
-      passengerName:       p.fullName,
-      status:              booking.status,
-      outboundSchedule:    { ...booking.schedule, seatClass: p.outboundSeat?.seatClass },
-      inboundSchedule:     isRoundTrip ? { ...booking.returnSchedule!, seatClass: p.returnSeat?.seatClass } : undefined,
+      passengerName:        p.fullName,
+      status:               booking.status,
+      outboundSchedule:     { ...booking.schedule, seatClass: p.outboundSeat?.seatClass },
+      inboundSchedule:      isRoundTrip ? { ...booking.returnSchedule!, seatClass: p.returnSeat?.seatClass } : undefined,
       isRoundTrip,
-      seatNumber:          isRoundTrip ? undefined : p.outboundSeat?.number,
-      outboundSeatNumber:  isRoundTrip ? p.outboundSeat?.number : undefined,
-      inboundSeatNumber:   isRoundTrip ? p.returnSeat?.number : undefined,
-      fareMinor:           voucherFareMinor,
-      currency:            voucherCurrency,
-      fareIsMajorUnits:    useSettledAmount,
-      createdAt:           booking.createdAt,
+      seatNumber:           isRoundTrip ? undefined : p.outboundSeat?.number,
+      coachNumber:          isRoundTrip ? undefined : p.outboundSeat?.coach,
+      outboundSeatNumber:   isRoundTrip ? p.outboundSeat?.number : undefined,
+      outboundCoachNumber:  isRoundTrip ? p.outboundSeat?.coach : undefined,
+      inboundSeatNumber:    isRoundTrip ? p.returnSeat?.number : undefined,
+      inboundCoachNumber:   isRoundTrip ? p.returnSeat?.coach : undefined,
+      fareMinor:            voucherFareMinor,
+      currency:             voucherCurrency,
+      fareIsMajorUnits:     useSettledAmount,
+      createdAt:            booking.createdAt,
     });
   }
 };
diff --git a/apps/edr-payment-api/src/modules/intents/intents.controller.ts b/apps/edr-payment-api/src/modules/intents/intents.controller.ts
index 35f3461d2..dc47adf6c 100644
--- a/apps/edr-payment-api/src/modules/intents/intents.controller.ts
+++ b/apps/edr-payment-api/src/modules/intents/intents.controller.ts
@@ -8,8 +8,12 @@ import {
   Query,
   UseGuards,
 } from "@nestjs/common";
-import { ApiOperation, ApiTags } from "@nestjs/swagger";
-import { PaymentIntentSnapshot } from "@edr/types";
+import { ApiOperation, ApiQuery, ApiTags } from "@nestjs/swagger";
+import {
+  PaymentIntentSnapshot,
+  ProviderMethod,
+  ProviderStatus,
+} from "@edr/types";
 import { ServiceAuthGuard } from "../../common/guards/service-auth.guard";
 import {
   InitiatePaymentRequestDto,
@@ -17,6 +21,7 @@ import {
 } from "./dto/initiate-payment.dto";
 import { ConfirmPaymentDto } from "./dto/confirm-payment.dto";
 import { IntentsService } from "./intents.service";
+import { PaymentIntent } from "./entities/payment-intent.entity";
 
 /**
  * Internal surface — called only by the domain apps (service-authenticated), never by
@@ -68,6 +73,41 @@ export class IntentsController {
     );
   }
 
+  @Get("diagnostic")
+  @ApiOperation({
+    summary: "DB row + live provider status by domain reference (diagnostic)",
+    description:
+      "Returns { db, provider } for a domain reference (service + referenceType + referenceId): " +
+      "the active stored intent row and a live provider status query, side by side. Pure read — " +
+      "does not mutate the intent. `db` is null when no active intent exists for the reference.",
+  })
+  async getDiagnosticByReference(
+    @Query() query: IntentReferenceQueryDto,
+  ): Promise<{ db: PaymentIntent | null; provider: ProviderStatus | null }> {
+    return this.intentsService.getDiagnosticByReference(
+      query.service,
+      query.referenceType,
+      query.referenceId,
+    );
+  }
+
+  @Get("by-merchant-order/:merchantOrderId")
+  @ApiOperation({
+    summary: "DB row + live provider status by merchant order id (diagnostic)",
+    description:
+      "Returns { db, provider } for a provider-facing merchant order id (PSG-/FRT-…): the " +
+      "stored intent row and a live provider status query, side by side. Pure read — does not " +
+      "mutate the intent. `db` is null when no intent has this merchant order id; supply " +
+      "`?provider=` in that case so the provider can still be queried by merchant order id.",
+  })
+  @ApiQuery({ name: "provider", enum: ProviderMethod, required: false })
+  async getByMerchantOrderId(
+    @Param("merchantOrderId") merchantOrderId: string,
+    @Query("provider") provider?: ProviderMethod,
+  ): Promise<{ db: PaymentIntent | null; provider: ProviderStatus | null }> {
+    return this.intentsService.getByMerchantOrderId(merchantOrderId, provider);
+  }
+
   @Post("intents/:id/confirm")
   @ApiOperation({
     summary: "Confirm an OTP-based payment intent (e.g. CAC Bank)",
diff --git a/apps/edr-payment-api/src/modules/intents/intents.service.ts b/apps/edr-payment-api/src/modules/intents/intents.service.ts
index c601395e8..704a46c2f 100644
--- a/apps/edr-payment-api/src/modules/intents/intents.service.ts
+++ b/apps/edr-payment-api/src/modules/intents/intents.service.ts
@@ -341,6 +341,90 @@ export class IntentsService {
     return this.toSnapshot(await this.refreshIfStale(intent));
   }
 
+  /**
+   * Diagnostic lookup by domain reference (service + referenceType + referenceId). Returns the
+   * stored intent AND a LIVE provider status query side by side — the reference-keyed twin of
+   * {@link getByMerchantOrderId}, used by the domain apps to resolve a booking/shipment without
+   * knowing the merchant order id. Pure read (no state-machine mutation).
+   *
+   * - `db`: the active stored intent for the reference, or `null` when none exists.
+   * - `provider`: the raw provider status response (queried using the intent's own provider), or
+   *   `null` when there is no intent or the query fails.
+   */
+  async getDiagnosticByReference(
+    service: PaymentService,
+    referenceType: PaymentReferenceType,
+    referenceId: string,
+  ): Promise<{ db: PaymentIntent | null; provider: ProviderStatus | null }> {
+    const intent = await this.intentsRepository.findActiveByReference(
+      service,
+      referenceType,
+      referenceId,
+    );
+    const providerStatus = intent
+      ? await this.queryProviderForMerchantOrder(
+          intent.merchantOrderId,
+          intent,
+          undefined,
+        )
+      : null;
+    return { db: intent ?? null, provider: providerStatus };
+  }
+
+  /**
+   * Diagnostic lookup by provider-facing merchant order id (PSG-/FRT-…). Returns the stored
+   * intent AND a LIVE provider status query side by side, so the caller can compare what the
+   * platform believes against what the provider currently reports. This is a pure read — it
+   * does NOT mutate the intent (no state-machine transition, no outbox event).
+   *
+   * - `db`: the full stored intent row, or `null` when no intent has this merchant order id.
+   * - `provider`: the raw provider status response. When there is a DB row its provider is
+   *   used; when there is no DB row a `providerHint` must be supplied to know which provider
+   *   to ask (the merchant-order prefix only identifies the service). `null` if the provider
+   *   is unknown or the query fails.
+   */
+  async getByMerchantOrderId(
+    merchantOrderId: string,
+    providerHint?: ProviderMethod,
+  ): Promise<{ db: PaymentIntent | null; provider: ProviderStatus | null }> {
+    const intent =
+      await this.intentsRepository.findByMerchantOrderId(merchantOrderId);
+
+    const providerStatus = await this.queryProviderForMerchantOrder(
+      merchantOrderId,
+      intent,
+      providerHint,
+    );
+
+    return { db: intent ?? null, provider: providerStatus };
+  }
+
+  /** Best-effort live provider status for a merchant order id; never throws (returns null). */
+  private async queryProviderForMerchantOrder(
+    merchantOrderId: string,
+    intent: PaymentIntent | null,
+    providerHint?: ProviderMethod,
+  ): Promise<ProviderStatus | null> {
+    try {
+      if (intent) {
+        const provider = this.providers.get(intent.provider);
+        if (!provider) return null;
+        return await this.queryProviderStatus(intent);
+      }
+      // No DB row — fall back to the caller-supplied provider hint keyed on merchantOrderId.
+      if (!providerHint) return null;
+      const provider = this.providers.get(providerHint);
+      if (!provider) return null;
+      return await provider.queryStatus(merchantOrderId);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      this.logger.warn(
+        `provider status query failed for merchantOrderId ${merchantOrderId}: ${message}`,
+      );
+      return null;
+    }
+  }
+
   /**
    * Pull-side reconciliation: when a polled intent is non-terminal and stale, ask the
    * provider for the truth and run the answer through the state machine. The browser
diff --git a/apps/edr-payment-api/src/modules/webhooks/handlers/telebirr-webhook.service.ts b/apps/edr-payment-api/src/modules/webhooks/handlers/telebirr-webhook.service.ts
index 44af7d985..8333e8e3b 100644
--- a/apps/edr-payment-api/src/modules/webhooks/handlers/telebirr-webhook.service.ts
+++ b/apps/edr-payment-api/src/modules/webhooks/handlers/telebirr-webhook.service.ts
@@ -18,7 +18,8 @@ export class TelebirrWebhookService {
     const signatureValid = true;
 
     const mapped = this.provider.mapWebhookTradeStatus(payload.trade_status);
-    const providerTxnId = payload.trans_id ?? payload.payment_order_id;
+    const providerTxnId =
+      payload.transId ?? payload.trans_id ?? payload.payment_order_id;
 
     await this.processor.process({
       provider: this.provider.method,
diff --git a/booking-checker.html b/booking-checker.html
new file mode 100644
index 000000000..9d2b7ded4
--- /dev/null
+++ b/booking-checker.html
@@ -0,0 +1,530 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>EDR Booking Checker</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+
+    body {
+      font-family: system-ui, sans-serif;
+      background: #f1f5f9;
+      color: #1e293b;
+      min-height: 100vh;
+      padding: 2rem;
+    }
+
+    h1 {
+      font-size: 1.25rem;
+      font-weight: 700;
+      margin-bottom: 1.5rem;
+      color: #0f172a;
+    }
+
+    .card {
+      background: #fff;
+      border-radius: 0.75rem;
+      border: 1px solid #e2e8f0;
+      padding: 1.5rem;
+      margin-bottom: 1.5rem;
+    }
+
+    label {
+      display: block;
+      font-size: 0.8rem;
+      font-weight: 600;
+      color: #475569;
+      margin-bottom: 0.4rem;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+
+    input[type="text"], textarea {
+      width: 100%;
+      border: 1px solid #cbd5e1;
+      border-radius: 0.5rem;
+      padding: 0.6rem 0.75rem;
+      font-size: 0.9rem;
+      outline: none;
+      transition: border-color 0.15s;
+    }
+
+    input[type="text"]:focus, textarea:focus {
+      border-color: #10b981;
+      box-shadow: 0 0 0 3px rgba(16,185,129,0.15);
+    }
+
+    textarea {
+      resize: vertical;
+      min-height: 140px;
+      font-family: monospace;
+      font-size: 0.85rem;
+    }
+
+    .hint { font-size: 0.75rem; color: #94a3b8; margin-top: 0.35rem; }
+
+    button {
+      background: #10b981;
+      color: #fff;
+      border: none;
+      border-radius: 0.5rem;
+      padding: 0.65rem 1.5rem;
+      font-size: 0.9rem;
+      font-weight: 600;
+      cursor: pointer;
+      transition: background 0.15s;
+    }
+    button:hover:not(:disabled) { background: #059669; }
+    button:disabled { background: #a7f3d0; cursor: not-allowed; }
+    .btn-secondary { background: #e2e8f0; color: #475569; }
+    .btn-secondary:hover:not(:disabled) { background: #cbd5e1; }
+
+    .btn-row { display: flex; gap: 0.75rem; align-items: center; margin-top: 1rem; flex-wrap: wrap; }
+
+    #status { font-size: 0.85rem; color: #64748b; }
+
+    .progress-bar-wrap {
+      width: 100%;
+      background: #e2e8f0;
+      border-radius: 9999px;
+      height: 6px;
+      margin-top: 0.75rem;
+      display: none;
+    }
+    .progress-bar {
+      height: 6px;
+      background: #10b981;
+      border-radius: 9999px;
+      transition: width 0.2s;
+      width: 0%;
+    }
+
+    .summary {
+      display: flex;
+      gap: 1.5rem;
+      flex-wrap: wrap;
+      margin-bottom: 1rem;
+      font-size: 0.85rem;
+      color: #475569;
+    }
+    .summary strong { color: #0f172a; }
+
+    .filter-row {
+      display: flex;
+      gap: 0.5rem;
+      margin-bottom: 1rem;
+      flex-wrap: wrap;
+    }
+    .filter-btn {
+      background: #f1f5f9;
+      color: #475569;
+      border: 1px solid #e2e8f0;
+      border-radius: 9999px;
+      padding: 0.3rem 0.9rem;
+      font-size: 0.78rem;
+      font-weight: 600;
+      cursor: pointer;
+    }
+    .filter-btn.active { background: #10b981; color: #fff; border-color: #10b981; }
+
+    .table-wrap { overflow-x: auto; }
+
+    table { width: 100%; border-collapse: collapse; font-size: 0.85rem; }
+
+    thead tr { background: #f8fafc; border-bottom: 2px solid #e2e8f0; }
+
+    th {
+      text-align: left;
+      padding: 0.6rem 0.75rem;
+      font-weight: 600;
+      color: #475569;
+      font-size: 0.75rem;
+      text-transform: uppercase;
+      letter-spacing: 0.04em;
+      white-space: nowrap;
+    }
+
+    td { padding: 0.6rem 0.75rem; border-bottom: 1px solid #f1f5f9; vertical-align: middle; }
+    tr:last-child td { border-bottom: none; }
+    tr:hover td { background: #f8fafc; }
+    tr.hidden-row { display: none; }
+
+    .badge {
+      display: inline-block;
+      padding: 0.2rem 0.55rem;
+      border-radius: 9999px;
+      font-size: 0.72rem;
+      font-weight: 600;
+    }
+    .badge-yes       { background: #fef3c7; color: #92400e; }
+    .badge-no        { background: #f1f5f9; color: #64748b; }
+    .badge-confirmed { background: #d1fae5; color: #065f46; }
+    .badge-cancelled { background: #fee2e2; color: #991b1b; }
+    .badge-pending   { background: #fef9c3; color: #854d0e; }
+    .badge-other     { background: #f1f5f9; color: #475569; }
+    .badge-dup       { background: #fee2e2; color: #991b1b; }
+
+    .error-row td { color: #ef4444; font-style: italic; }
+    .dup-row td   { background: #fff5f5; }
+    .dup-cell { background:#fee2e2;color:#991b1b;border-radius:6px;padding:0.4rem 0.6rem;display:inline-block;font-weight:600;font-size:0.82rem; }
+
+    #results-section { display: none; }
+
+    .export-btn { background: #6366f1; }
+    .export-btn:hover:not(:disabled) { background: #4f46e5; }
+  </style>
+</head>
+<body>
+
+<h1>EDR Booking Checker</h1>
+
+<div class="card">
+  <label for="base-url">API Base URL</label>
+  <input type="text" id="base-url" value="http://localhost:4000" />
+  <p class="hint">No trailing slash. e.g. https://api.edrsc.com</p>
+</div>
+
+<div class="card">
+  <label for="refs">Booking References</label>
+  <textarea id="refs" placeholder="ABCDEF&#10;GHIJKL&#10;MNOPQR&#10;One per line, comma-separated, or wrapped in {curly,braces}"></textarea>
+  <p class="hint">Supports any format: one per line, comma-separated, or <code>{REF1,REF2}</code> groups.</p>
+
+  <div class="btn-row">
+    <button id="run-btn" onclick="run()">Check Bookings</button>
+    <button class="btn-secondary" onclick="clearAll()">Clear</button>
+    <button class="btn-secondary export-btn" onclick="exportCSV()" id="export-btn" style="display:none;background:#6366f1;color:#fff;">Export CSV</button>
+    <span id="status"></span>
+  </div>
+  <div class="progress-bar-wrap" id="progress-wrap">
+    <div class="progress-bar" id="progress-bar"></div>
+  </div>
+</div>
+
+<div class="card" id="results-section">
+  <div class="summary" id="summary"></div>
+
+  <div class="filter-row">
+    <button class="filter-btn active" onclick="setFilter('all', this)">All</button>
+    <button class="filter-btn" onclick="setFilter('package', this)">Package Only</button>
+    <button class="filter-btn" onclick="setFilter('regular', this)">Regular Only</button>
+    <button class="filter-btn" onclick="setFilter('error', this)">Errors Only</button>
+    <button class="filter-btn" onclick="setFilter('dup', this)">Duplicate Seats</button>
+  </div>
+  <div style="margin-bottom:1rem;display:flex;align-items:center;gap:0.5rem;flex-wrap:wrap">
+    <label for="date-filter" style="margin:0;text-transform:none;font-size:0.82rem;letter-spacing:0">Date:</label>
+    <input type="text" id="date-filter" placeholder="e.g. 18 Jul 2026" style="width:160px" oninput="applyFilter(currentFilter)" />
+    <label for="route-filter" style="margin:0;text-transform:none;font-size:0.82rem;letter-spacing:0">Route:</label>
+    <input type="text" id="route-filter" placeholder="e.g. DIR or BISH" style="width:160px" oninput="applyFilter(currentFilter)" />
+    <label for="class-filter" style="margin:0;text-transform:none;font-size:0.82rem;letter-spacing:0">Seat Class:</label>
+    <input type="text" id="class-filter" placeholder="e.g. VIP" style="width:140px" oninput="applyFilter(currentFilter)" />
+    <span id="row-count" style="font-size:0.82rem;color:#64748b;margin-left:0.5rem"></span>
+  </div>
+
+  <div class="table-wrap">
+    <table>
+      <thead>
+        <tr>
+          <th>Journey</th>
+          <th>Duplicate Bookings</th>
+        </tr>
+      </thead>
+      <tbody id="tbody"></tbody>
+    </table>
+  </div>
+</div>
+
+<script>
+  let allRows = [];
+  let currentFilter = 'all';
+
+  function parseRefs(raw) {
+    // Remove curly braces, split on newlines/commas, deduplicate
+    const cleaned = raw.replace(/[{}]/g, ' ');
+    const refs = cleaned.split(/[\n,\s]+/).map(r => r.trim()).filter(Boolean);
+    return [...new Set(refs)];
+  }
+
+  function statusBadge(status) {
+    if (!status) return '<span class="badge badge-other">—</span>';
+    const s = status.toUpperCase();
+    const cls = s === 'CONFIRMED' ? 'confirmed'
+              : s === 'CANCELLED' ? 'cancelled'
+              : s.includes('PENDING') ? 'pending'
+              : 'other';
+    return `<span class="badge badge-${cls}">${status}</span>`;
+  }
+
+  async function run() {
+    const baseUrl = document.getElementById('base-url').value.trim().replace(/\/$/, '');
+    const refs = parseRefs(document.getElementById('refs').value);
+
+    if (!refs.length) { setStatus('Enter at least one booking reference.'); return; }
+
+    const btn = document.getElementById('run-btn');
+    btn.disabled = true;
+    document.getElementById('export-btn').style.display = 'none';
+    document.getElementById('results-section').style.display = 'none';
+    document.getElementById('progress-wrap').style.display = 'block';
+    setProgress(0);
+    setStatus(`Checking ${refs.length} booking(s)…`);
+
+    allRows = [];
+    let done = 0;
+
+    // Run in batches of 20 to avoid overwhelming the server
+    const BATCH = 20;
+    for (let i = 0; i < refs.length; i += BATCH) {
+      const batch = refs.slice(i, i + BATCH);
+      const batchResults = await Promise.all(
+        batch.map(async (ref) => {
+          try {
+            const proxyUrl = `http://localhost:8080/proxy?url=${encodeURIComponent(`${baseUrl}/bookings/${ref}`)}`;
+            const res = await fetch(proxyUrl);
+            if (!res.ok) throw new Error(`HTTP ${res.status}`);
+            const json = await res.json();
+            const d = json.data ?? json;
+            return {
+              ref,
+              status: d.status ?? 'UNKNOWN',
+              bookingType: d.bookingType ?? '—',
+              isPackage: d.isPackageBooking ?? !!d.packageId,
+              packageName: d.packageName ?? '—',
+              packageId: d.packageId ?? '—',
+              passengerNames: (d.passengers ?? []).map(p => p.fullName ?? '—').join(', '),
+              phone: d.contactPhone ?? '—',
+              coaches: (d.passengers ?? []).map(p => p.seat?.coach ?? '—').join(', '),
+              seatNumbers: (d.passengers ?? []).map(p => p.seat?.number ?? '—').join(', '),
+              seatClasses: (d.passengers ?? []).map(p => p.seat?.seatClass ?? '—').join(', '),
+              seatIds: (d.passengers ?? []).map(p => p.seat?.id).filter(Boolean),
+              seats: (d.passengers ?? []).map(p => {
+                const legScheduleMap = {
+                  1: d.schedule?.id,
+                  2: d.bookingType === 'ROUND_TRIP' ? d.returnSchedule?.id : d.leg2Schedule?.id,
+                  3: d.returnSchedule?.id,
+                  4: d.returnLeg2Schedule?.id,
+                };
+                const legScheduleObjMap = {
+                  1: d.schedule,
+                  2: d.bookingType === 'ROUND_TRIP' ? d.returnSchedule : d.leg2Schedule,
+                  3: d.returnSchedule,
+                  4: d.returnLeg2Schedule,
+                };
+                const sched = legScheduleObjMap[p.leg] ?? d.schedule;
+                const scheduleId = sched?.id ?? null;
+                const originSeq = sched?.origin?.sequence ?? sched?.originStation?.sequence ?? 0;
+                const destSeq   = sched?.destination?.sequence ?? sched?.destinationStation?.sequence ?? 999;
+                const depMap = {
+                  1: d.schedule?.departureAt,
+                  2: d.bookingType === 'ROUND_TRIP' ? d.returnSchedule?.departureAt : d.leg2Schedule?.departureAt,
+                  3: d.returnSchedule?.departureAt,
+                  4: d.returnLeg2Schedule?.departureAt,
+                };
+                const departureAt = depMap[p.leg] ?? d.schedule?.departureAt;
+                const depDate = departureAt ? new Date(departureAt).toLocaleDateString('en-GB', { day:'2-digit', month:'short', year:'numeric' }) : '—';
+                const legLabel = d.bookingType === 'ONE_WAY' ? 'Outbound'
+                  : d.bookingType === 'ROUND_TRIP'
+                    ? (p.leg === 1 ? 'Outbound' : 'Return')
+                  : d.bookingType === 'TRANSIT'
+                    ? (p.leg === 1 ? 'Outbound Leg 1' : 'Outbound Leg 2')
+                  : d.bookingType === 'ROUND_TRIP_TRANSIT'
+                    ? (p.leg === 1 ? 'Outbound Leg 1' : p.leg === 2 ? 'Outbound Leg 2' : p.leg === 3 ? 'Return Leg 1' : 'Return Leg 2')
+                  : `Leg ${p.leg}`;
+                return { scheduleId, originSeq, destSeq, depDate, legLabel, coach: p.seat?.coach ?? '—', number: p.seat?.number ?? '—', seatClass: p.seat?.seatClass ?? '—' };
+              }),
+              origin: d.schedule?.origin?.code ?? d.schedule?.origin?.name ?? '—',
+              destination: d.schedule?.destination?.code ?? d.schedule?.destination?.name ?? '—',
+              hasDupSeat: false,
+              dupSeatRefs: [],
+              error: null,
+            };
+          } catch (e) {
+            return { ref, status: 'ERROR', bookingType: '—', isPackage: false, packageName: '—', packageId: '—', passengerNames: '—', phone: '—', seatClasses: '—', seatIds: [], seats: [], origin: '—', destination: '—', hasDupSeat: false, dupSeatRefs: [], dupSeatIds: new Set(), error: e.message };
+          }
+        })
+      );
+      allRows.push(...batchResults);
+      done += batch.length;
+      setProgress(Math.round((done / refs.length) * 100));
+      setStatus(`Checked ${done} / ${refs.length}…`);
+    }
+
+    detectDuplicateSeats();
+    renderTable();
+    renderSummary();
+
+    document.getElementById('results-section').style.display = 'block';
+    document.getElementById('export-btn').style.display = 'inline-block';
+    document.getElementById('progress-wrap').style.display = 'none';
+    setStatus('');
+    btn.disabled = false;
+  }
+
+  function detectDuplicateSeats() {
+    // Group seats by scheduleId|coach|seatNumber
+    // Two bookings conflict if they share the same seat on the same schedule
+    // AND their origin→destination sequence ranges overlap
+    const seatMap = new Map(); // key: scheduleId|coach|seat -> [{ref, originSeq, destSeq}]
+    for (const row of allRows) {
+      if (row.error) continue;
+      for (const seat of row.seats) {
+        if (!seat.scheduleId || seat.coach === '—' || seat.number === '—') continue;
+        const key = `${seat.scheduleId}|${seat.coach}|${seat.number}`;
+        if (!seatMap.has(key)) seatMap.set(key, []);
+        seatMap.get(key).push({ ref: row.ref, originSeq: seat.originSeq, destSeq: seat.destSeq });
+      }
+    }
+
+    // Two segments [a1,a2] and [b1,b2] overlap if a1 < b2 && b1 < a2
+    function overlaps(a1, a2, b1, b2) { return a1 < b2 && b1 < a2; }
+
+    for (const row of allRows) {
+      if (row.error) continue;
+      const dupRefs = new Set();
+      const dupSeatKeys = new Set();
+      for (const seat of row.seats) {
+        if (!seat.scheduleId) continue;
+        const key = `${seat.scheduleId}|${seat.coach}|${seat.number}`;
+        const entries = seatMap.get(key) ?? [];
+        for (const other of entries) {
+          if (other.ref === row.ref) continue;
+          if (overlaps(seat.originSeq, seat.destSeq, other.originSeq, other.destSeq)) {
+            dupRefs.add(other.ref);
+            dupSeatKeys.add(`${seat.coach}|${seat.number}`);
+          }
+        }
+      }
+      row.hasDupSeat = dupRefs.size > 0;
+      row.dupSeatRefs = [...dupRefs];
+      row.dupSeatIds = dupSeatKeys;
+    }
+  }
+
+  function buildDupGroups() {
+    const groups = new Map();
+    for (const row of allRows) {
+      if (row.error || !row.hasDupSeat) continue;
+      const names = row.passengerNames.split(', ');
+      for (const seat of row.seats) {
+        if (!row.dupSeatIds.has(`${seat.coach}|${seat.number}`)) continue;
+        const key = `${seat.depDate}|${seat.legLabel}|${row.origin}→${row.destination}|${seat.seatClass}|${seat.coach}|${seat.number}`;
+        if (!groups.has(key)) groups.set(key, { entries: [], isPackage: false });
+        const name = (names[row.seats.indexOf(seat)] ?? '').trim() || '—';
+        groups.get(key).entries.push({ ref: row.ref, name, phone: row.phone, isPackage: row.isPackage });
+        if (row.isPackage) groups.get(key).isPackage = true;
+      }
+    }
+    return groups;
+  }
+
+  function renderTable() {
+    const tbody = document.getElementById('tbody');
+    tbody.innerHTML = '';
+    const groups = buildDupGroups();
+    if (!groups.size) return;
+
+    for (const [key, { entries, isPackage }] of groups) {
+      if (new Set(entries.map(e => e.ref)).size < 2) continue;
+      const [depDate, legLabel, route, seatClass, coach, seatNum] = key.split('|');
+      const tr = document.createElement('tr');
+      tr.dataset.dup = '1';
+      tr.dataset.type = isPackage ? 'package' : 'regular';
+      tr.dataset.date = depDate;
+      tr.dataset.route = route;
+      tr.dataset.seatclass = seatClass.toLowerCase();
+      tr.classList.add('dup-row');
+
+      const journeyCell = `<td style="white-space:nowrap">${depDate} · ${legLabel} · ${route} · ${seatClass} · ${coach}-${seatNum}</td>`;
+
+      const bookingsCell = `<td>${entries.map(e =>
+        `<div style="margin-bottom:0.5rem">
+          <span class="dup-cell">${e.ref}</span>
+          <span style="margin-left:0.4rem">${e.name}</span>
+          <span style="font-size:0.78rem;color:#64748b;margin-left:0.4rem">${e.phone}</span>
+        </div>`
+      ).join('')}</td>`;
+
+      tr.innerHTML = journeyCell + bookingsCell;
+      tbody.appendChild(tr);
+    }
+    applyFilter(currentFilter);
+  }
+
+  function renderSummary() {
+    const total    = allRows.length;
+    const pkgCount = allRows.filter(r => r.isPackage).length;
+    const errCount = allRows.filter(r => r.error).length;
+    const dupCount = allRows.filter(r => r.hasDupSeat).length;
+    const regCount = total - pkgCount - errCount;
+    document.getElementById('summary').innerHTML = `
+      <span>Total: <strong>${total}</strong></span>
+      <span>Package: <strong>${pkgCount}</strong></span>
+      <span>Regular: <strong>${regCount}</strong></span>
+      ${errCount ? `<span style="color:#ef4444">Errors: <strong>${errCount}</strong></span>` : ''}
+      ${dupCount ? `<span style="color:#dc2626">⚠ Duplicate Seats: <strong>${dupCount}</strong></span>` : ''}
+    `;
+  }
+
+  function setFilter(type, btn) {
+    currentFilter = type;
+    document.querySelectorAll('.filter-btn').forEach(b => b.classList.remove('active'));
+    btn.classList.add('active');
+    applyFilter(type);
+  }
+
+  function applyFilter(type) {
+    const dateQ = (document.getElementById('date-filter')?.value ?? '').trim().toLowerCase();
+    const routeQ = (document.getElementById('route-filter')?.value ?? '').trim().toLowerCase();
+    const classQ = (document.getElementById('class-filter')?.value ?? '').trim().toLowerCase();
+    let visible = 0;
+    document.querySelectorAll('#tbody tr').forEach(tr => {
+      const t = tr.dataset.type;
+      const typeMatch = type === 'all'
+        || (type === 'package' && t === 'package')
+        || (type === 'regular' && t === 'regular')
+        || (type === 'error'   && t === 'error')
+        || (type === 'dup'     && tr.dataset.dup === '1');
+      const dateMatch = !dateQ || (tr.dataset.date ?? '').toLowerCase().includes(dateQ);
+      const routeMatch = !routeQ || (tr.dataset.route ?? '').toLowerCase().includes(routeQ);
+      const classMatch = !classQ || (tr.dataset.seatclass ?? '').includes(classQ);
+      const show = typeMatch && dateMatch && routeMatch && classMatch;
+      tr.classList.toggle('hidden-row', !show);
+      if (show) visible++;
+    });
+    document.getElementById('row-count').textContent = `Showing ${visible} row${visible !== 1 ? 's' : ''}`;
+  }
+
+  function exportCSV() {
+    const header = 'Booking Ref,Status,Booking Type,Is Package,Package Name,Package ID,Passenger(s),Phone,Coach-Seat,Seat Class,Duplicate Seat In';
+    const lines = allRows.map(r =>
+      [r.ref, r.status, r.bookingType, r.isPackage, r.packageName, r.packageId, r.seats.map((s, idx) => `${(r.passengerNames.split(', ')[idx] ?? '').trim()} · ${s.legLabel} · ${s.seatClass} · ${r.origin}→${r.destination} · ${s.coach}-${s.number}`).join('; '), r.phone, r.seatClasses, r.dupSeatRefs.join('; ') || '']
+        .map(v => `"${String(v).replace(/"/g, '""')}"`)
+        .join(',')
+    );
+    const csv = [header, ...lines].join('\n');
+    const blob = new Blob([csv], { type: 'text/csv' });
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(blob);
+    a.download = 'booking-check-' + new Date().toISOString().slice(0,10) + '.csv';
+    a.click();
+  }
+
+  function clearAll() {
+    document.getElementById('date-filter').value = '';
+    document.getElementById('route-filter').value = '';
+    document.getElementById('class-filter').value = '';
+    document.getElementById('refs').value = '';
+    document.getElementById('tbody').innerHTML = '';
+    document.getElementById('results-section').style.display = 'none';
+    document.getElementById('export-btn').style.display = 'none';
+    document.getElementById('progress-wrap').style.display = 'none';
+    allRows = [];
+    setStatus('');
+  }
+
+  function setStatus(msg) { document.getElementById('status').textContent = msg; }
+  function setProgress(pct) { document.getElementById('progress-bar').style.width = pct + '%'; }
+</script>
+
+</body>
+</html>
diff --git a/booking-extractor.html b/booking-extractor.html
new file mode 100644
index 000000000..844c98b2c
--- /dev/null
+++ b/booking-extractor.html
@@ -0,0 +1,256 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>EDR Booking Extractor</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, sans-serif; background: #f1f5f9; color: #1e293b; min-height: 100vh; padding: 2rem; }
+    h1 { font-size: 1.25rem; font-weight: 700; margin-bottom: 1.5rem; color: #0f172a; }
+    .card { background: #fff; border-radius: 0.75rem; border: 1px solid #e2e8f0; padding: 1.5rem; margin-bottom: 1.5rem; }
+    label { display: block; font-size: 0.8rem; font-weight: 600; color: #475569; margin-bottom: 0.4rem; text-transform: uppercase; letter-spacing: 0.05em; }
+    .hint { font-size: 0.75rem; color: #94a3b8; margin-top: 0.35rem; }
+    .drop-zone {
+      border: 2px dashed #cbd5e1; border-radius: 0.5rem; padding: 2rem;
+      text-align: center; cursor: pointer; color: #94a3b8; font-size: 0.9rem;
+      transition: border-color 0.15s, background 0.15s;
+    }
+    .drop-zone.over { border-color: #10b981; background: #f0fdf4; color: #065f46; }
+    .drop-zone input[type="file"] { display: none; }
+    button {
+      background: #10b981; color: #fff; border: none; border-radius: 0.5rem;
+      padding: 0.65rem 1.5rem; font-size: 0.9rem; font-weight: 600; cursor: pointer; transition: background 0.15s;
+    }
+    button:hover:not(:disabled) { background: #059669; }
+    button:disabled { background: #a7f3d0; cursor: not-allowed; }
+    .btn-secondary { background: #e2e8f0; color: #475569; }
+    .btn-secondary:hover:not(:disabled) { background: #cbd5e1; }
+    .export-btn { background: #6366f1; color: #fff; }
+    .export-btn:hover:not(:disabled) { background: #4f46e5; }
+    .btn-row { display: flex; gap: 0.75rem; align-items: center; margin-top: 1rem; flex-wrap: wrap; }
+    #status { font-size: 0.85rem; color: #64748b; }
+    .summary { display: flex; gap: 1.5rem; flex-wrap: wrap; margin-bottom: 1rem; font-size: 0.85rem; color: #475569; }
+    .summary strong { color: #0f172a; }
+    .table-wrap { overflow-x: auto; }
+    table { width: 100%; border-collapse: collapse; font-size: 0.82rem; }
+    thead tr { background: #f8fafc; border-bottom: 2px solid #e2e8f0; }
+    th { text-align: left; padding: 0.5rem 0.75rem; font-weight: 600; color: #475569; font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.04em; white-space: nowrap; }
+    td { padding: 0.5rem 0.75rem; border-bottom: 1px solid #f1f5f9; vertical-align: middle; }
+    tr:last-child td { border-bottom: none; }
+    tr:hover td { background: #f8fafc; }
+    #results-section { display: none; }
+  </style>
+</head>
+<body>
+
+<h1>EDR Booking Extractor</h1>
+
+<div class="card">
+  <label>Bookings JSON File</label>
+  <div class="drop-zone" id="drop-zone" onclick="document.getElementById('file-input').click()">
+    <input type="file" id="file-input" accept=".json" onchange="handleFile(this.files[0])" />
+    Drop <code>bookings.json</code> here or click to browse
+  </div>
+  <p class="hint">Accepts a JSON array of bookings or an object with a <code>bookings</code> key.</p>
+  <div class="btn-row">
+    <button class="btn-secondary" onclick="clearAll()">Clear</button>
+    <button class="export-btn" id="export-btn" onclick="exportCSV()" style="display:none">Export CSV</button>
+    <span id="status"></span>
+  </div>
+</div>
+
+<div class="card" id="results-section">
+  <div class="summary" id="summary"></div>
+  <div style="margin-bottom:1rem;display:flex;align-items:center;gap:0.5rem;flex-wrap:wrap">
+    <label for="date-filter" style="margin:0;text-transform:none;font-size:0.82rem;letter-spacing:0">Departure Date:</label>
+    <input type="text" id="date-filter" placeholder="e.g. 18 Jul 2026" style="width:160px;border:1px solid #cbd5e1;border-radius:0.5rem;padding:0.4rem 0.6rem;font-size:0.85rem;outline:none" oninput="applyFilter()" />
+    <span id="row-count" style="font-size:0.82rem;color:#64748b"></span>
+  </div>
+  <div class="table-wrap">
+    <table>
+      <thead>
+        <tr>
+          <th>#</th>
+          <th>Booking Ref</th>
+          <th>Status</th>
+          <th>Booking Type</th>
+          <th>Phone</th>
+          <th>Email</th>
+          <th>Departure</th>
+          <th>Origin</th>
+          <th>Destination</th>
+          <th>Passenger(s)</th>
+          <th>Coach - Seat</th>
+          <th>Payment Method</th>
+          <th>Payment Status</th>
+          <th>Total (DJF)</th>
+          <th>Created At</th>
+        </tr>
+      </thead>
+      <tbody id="tbody"></tbody>
+    </table>
+  </div>
+</div>
+
+<script>
+  let extracted = [];
+
+  function fmt(v) { return v ?? ''; }
+
+  function extractRow(b) {
+    const seats = (b.seats ?? b.passengers ?? []);
+    const passengerNames = seats.map(s => s.passengerName ?? s.name ?? '').filter(Boolean).join(', ');
+    const coachSeats = seats.map(s => {
+      const num = s.seat?.seatNumber ?? '';
+      const coach = typeof s.seat?.coach === 'string' ? s.seat.coach : (s.seat?.coach?.number ?? '');
+      return coach && num ? `${coach}-${num}` : (num || coach || '');
+    }).filter(Boolean).join(', ');
+
+    const dep = b.schedule?.departureAt
+      ? new Date(b.schedule.departureAt).toLocaleString('en-GB', { day: '2-digit', month: 'short', year: 'numeric', hour: '2-digit', minute: '2-digit' })
+      : '';
+    const createdAt = b.createdAt
+      ? new Date(b.createdAt).toLocaleString('en-GB', { day: '2-digit', month: 'short', year: 'numeric', hour: '2-digit', minute: '2-digit' })
+      : '';
+
+    return {
+      booking_ref:      fmt(b.bookingRef),
+      status:           fmt(b.status),
+      booking_type:     fmt(b.bookingType),
+      phone:            fmt(b.contactPhone),
+      email:            fmt(b.contactEmail),
+      departure:        dep,
+      origin:           fmt(b.schedule?.originStation?.code),
+      destination:      fmt(b.schedule?.destinationStation?.code),
+      passenger_names:  passengerNames,
+      coach_seat:       coachSeats,
+      payment_method:   fmt(b.paymentIntent?.method),
+      payment_status:   fmt(b.paymentIntent?.status),
+      total:            b.displayTotalMinor != null ? (b.displayTotalMinor / 100).toFixed(2) : '',
+      created_at:       createdAt,
+    };
+  }
+
+  function extractObjects(text) {
+    const results = [];
+    let depth = 0, start = -1, inString = false, escape = false;
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (escape) { escape = false; continue; }
+      if (ch === '\\' && inString) { escape = true; continue; }
+      if (ch === '"') { inString = !inString; continue; }
+      if (inString) continue;
+      if (ch === '{') { if (depth === 0) start = i; depth++; }
+      else if (ch === '}') {
+        depth--;
+        if (depth === 0 && start !== -1) {
+          try { results.push(JSON.parse(text.slice(start, i + 1))); } catch (_) {}
+          start = -1;
+        }
+      }
+    }
+    return results;
+  }
+
+  window.handleFile = function(file) {
+    if (!file) return;
+    setStatus(`Reading ${file.name}…`);
+    const reader = new FileReader();
+    reader.onload = e => {
+      try {
+        const text = e.target.result.replace(/^\uFEFF/, '');
+        let bookings = [], parseWarning = '';
+        try {
+          const data = JSON.parse(text);
+          bookings = Array.isArray(data) ? data : (data.bookings ?? []);
+        } catch (_) {
+          bookings = extractObjects(text);
+          parseWarning = `⚠ File was truncated — recovered ${bookings.length} complete record(s).`;
+        }
+        if (!bookings.length) throw new Error('No booking records found in the JSON.');
+        extracted = bookings.map(extractRow);
+        renderTable();
+        document.getElementById('results-section').style.display = 'block';
+        document.getElementById('export-btn').style.display = 'inline-block';
+        document.getElementById('summary').innerHTML = `Loaded <strong>${extracted.length}</strong> booking(s) from <strong>${file.name}</strong>`;
+        setStatus(parseWarning);
+      } catch (err) {
+        setStatus(`Error: ${err.message}`);
+      }
+    };
+    reader.readAsText(file);
+  };
+
+  const HEADERS = ['booking_ref','status','booking_type','phone','email','departure','origin','destination','passenger_names','coach_seat','payment_method','payment_status','total','created_at'];
+
+  function renderTable() {
+    const tbody = document.getElementById('tbody');
+    tbody.innerHTML = '';
+    extracted.forEach((row, i) => {
+      const tr = document.createElement('tr');
+      tr.dataset.departure = row.departure.toLowerCase();
+      tr.innerHTML = `
+        <td>${i + 1}</td>
+        <td><code>${row.booking_ref || '—'}</code></td>
+        <td>${row.status || '—'}</td>
+        <td>${row.booking_type || '—'}</td>
+        <td>${row.phone || '—'}</td>
+        <td>${row.email || '—'}</td>
+        <td>${row.departure || '—'}</td>
+        <td>${row.origin || '—'}</td>
+        <td>${row.destination || '—'}</td>
+        <td>${row.passenger_names || '—'}</td>
+        <td>${row.coach_seat || '—'}</td>
+        <td>${row.payment_method || '—'}</td>
+        <td>${row.payment_status || '—'}</td>
+        <td>${row.total || '—'}</td>
+        <td>${row.created_at || '—'}</td>`;
+      tbody.appendChild(tr);
+    });
+    applyFilter();
+  }
+
+  function applyFilter() {
+    const q = (document.getElementById('date-filter')?.value ?? '').trim().toLowerCase();
+    let visible = 0;
+    document.querySelectorAll('#tbody tr').forEach(tr => {
+      const show = !q || (tr.dataset.departure ?? '').includes(q);
+      tr.style.display = show ? '' : 'none';
+      if (show) visible++;
+    });
+    document.getElementById('row-count').textContent = `Showing ${visible} row${visible !== 1 ? 's' : ''}`;
+  }
+
+  window.exportCSV = function() {
+    const header = HEADERS.join(',');
+    const lines = extracted.map(row =>
+      HEADERS.map(k => `"${String(row[k] ?? '').replace(/"/g, '""')}"`).join(',')
+    );
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(new Blob([[header, ...lines].join('\n')], { type: 'text/csv' }));
+    a.download = 'bookings_extracted.csv';
+    a.click();
+  };
+
+  window.clearAll = function() {
+    extracted = [];
+    document.getElementById('tbody').innerHTML = '';
+    document.getElementById('results-section').style.display = 'none';
+    document.getElementById('export-btn').style.display = 'none';
+    document.getElementById('file-input').value = '';
+    document.getElementById('date-filter').value = '';
+    document.getElementById('row-count').textContent = '';
+    setStatus('');
+  };
+
+  function setStatus(msg) { document.getElementById('status').textContent = msg; }
+
+  const dz = document.getElementById('drop-zone');
+  dz.addEventListener('dragover', e => { e.preventDefault(); dz.classList.add('over'); });
+  dz.addEventListener('dragleave', () => dz.classList.remove('over'));
+  dz.addEventListener('drop', e => { e.preventDefault(); dz.classList.remove('over'); handleFile(e.dataTransfer.files[0]); });
+</script>
+
+</body>
+</html>
diff --git a/booking-proxy.mjs b/booking-proxy.mjs
new file mode 100644
index 000000000..27f9248ee
--- /dev/null
+++ b/booking-proxy.mjs
@@ -0,0 +1,53 @@
+import http from 'http';
+import https from 'https';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const PORT = 8080;
+const __dir = path.dirname(fileURLToPath(import.meta.url));
+
+const server = http.createServer((req, res) => {
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+
+  if (req.method === 'OPTIONS') { res.writeHead(204); res.end(); return; }
+
+  // Serve any .html file in the same directory
+  if (req.url === '/' || req.url.endsWith('.html')) {
+    const filename = req.url === '/' ? 'booking-checker.html' : req.url.slice(1);
+    const filepath = path.join(__dir, filename);
+    if (fs.existsSync(filepath)) {
+      res.writeHead(200, { 'Content-Type': 'text/html' });
+      fs.createReadStream(filepath).pipe(res);
+    } else {
+      res.writeHead(404); res.end('Not found');
+    }
+    return;
+  }
+
+  // Proxy /proxy?url=<encoded-api-url>
+  if (req.url.startsWith('/proxy?url=')) {
+    const target = decodeURIComponent(req.url.slice('/proxy?url='.length));
+    const parsed = new URL(target);
+    const mod = parsed.protocol === 'https:' ? https : http;
+    const options = {
+      hostname: parsed.hostname,
+      port: parsed.port || (parsed.protocol === 'https:' ? 443 : 80),
+      path: parsed.pathname + parsed.search,
+      method: req.method,
+      headers: { ...req.headers, host: parsed.hostname },
+    };
+    const proxy = mod.request(options, (apiRes) => {
+      res.writeHead(apiRes.statusCode, apiRes.headers);
+      apiRes.pipe(res);
+    });
+    proxy.on('error', (e) => { res.writeHead(502); res.end(e.message); });
+    req.pipe(proxy);
+    return;
+  }
+
+  res.writeHead(404); res.end();
+});
+
+server.listen(PORT, () => console.log(`Booking checker: http://localhost:${PORT}/booking-checker.html`));
diff --git a/packages/payment-providers/src/webhooks/telebirr-webhook.types.ts b/packages/payment-providers/src/webhooks/telebirr-webhook.types.ts
index 39a0f60f8..d9174627b 100644
--- a/packages/payment-providers/src/webhooks/telebirr-webhook.types.ts
+++ b/packages/payment-providers/src/webhooks/telebirr-webhook.types.ts
@@ -2,6 +2,9 @@ export interface TelebirrWebhookPayload {
   merch_order_id: string;
   payment_order_id: string;
   trade_status: string;
+  /** Telebirr's webhook (notify) sends the transaction id as camelCase `transId`;
+   *  the queryOrder/status-query biz_content uses snake_case `trans_id`. Support both. */
+  transId?: string;
   trans_id?: string;
   total_amount?: string;
   trans_currency?: string;
diff --git a/packages/types/src/freight/contracts.ts b/packages/types/src/freight/contracts.ts
index 9aa36374a..299c25dc9 100644
--- a/packages/types/src/freight/contracts.ts
+++ b/packages/types/src/freight/contracts.ts
@@ -407,6 +407,8 @@ export interface ContractClearanceView {
   /** Customs risk level assigned by GL ET (import; visible to the customer). */
   riskLevel?: string | null;
   riskAssignedAt?: string | null;
+  /** Every risk decision, oldest first; the last entry is the current level. */
+  riskHistory?: RiskAssignmentRecord[];
   /** Post-arrival additional duty/tax round (import). */
   secondDuty?: ClearanceSecondDuty | null;
   importReleaseGranted?: boolean;
@@ -440,9 +442,27 @@ export type MilestoneStatus = "PENDING" | "COMPLETED" | "SKIPPED";
 export const CUSTOMS_RISK_LEVELS = ["GREEN", "YELLOW", "RED"] as const;
 export type CustomsRiskLevel = (typeof CUSTOMS_RISK_LEVELS)[number];
 
+/**
+ * One customs risk decision. The level stays correctable until duty is advised
+ * off it and is customer-visible, so every assignment is kept rather than
+ * overwritten.
+ */
+export interface RiskAssignmentRecord {
+  level: CustomsRiskLevel;
+  /** The level this replaced; absent on the first assignment. */
+  previousLevel?: CustomsRiskLevel;
+  assignedAt: string;
+  assignedByUserId?: string | null;
+  /** Display name resolved at assignment time, so the trail never shows a UUID. */
+  assignedBy?: string | null;
+  note?: string | null;
+}
+
 /** Structured payload carried by RISK_ASSIGNED / DUTY_TAXES_ADVISED milestones. */
 export interface MilestoneMetadata {
   riskLevel?: CustomsRiskLevel;
+  /** Every risk decision, oldest first; the last entry matches `riskLevel`. */
+  riskHistory?: RiskAssignmentRecord[];
   dutyAmount?: number;
   dutyCurrency?: string;
   declarationSerial?: string;
@@ -729,14 +749,22 @@ export interface CreateContainerUnitDto {
   containerNumber: string;
   sealNumber?: string;
   vgmTons: number;
+  /** Per-container handling opt-ins, entered alongside this container's VGM. */
   isHazardous?: boolean;
   isReefer?: boolean;
+  /** This container ships back empty (equipment return). */
+  isReturn?: boolean;
 }
 
 export interface CreateBookingContainerLineDto {
   /** "20ft" | "40ft" — must be in the contract's cargo scope. */
   containerSize: string;
   quantity: number;
+  /**
+   * Line totals, derived from the per-unit switches above. The API recomputes
+   * them from `units` whenever any unit carries a flag, so they are only
+   * authoritative for callers that don't send per-unit flags.
+   */
   hazardousQuantity?: number;
   reeferQuantity?: number;
   /**
diff --git a/packages/types/src/freight/index.ts b/packages/types/src/freight/index.ts
index 12f3d548f..be13ed349 100644
--- a/packages/types/src/freight/index.ts
+++ b/packages/types/src/freight/index.ts
@@ -137,6 +137,8 @@ export enum TrainStatus {
   InService = "IN_SERVICE",
   UnderMaintenance = "UNDER_MAINTENANCE",
   OutOfService = "OUT_OF_SERVICE",
+  /** Parked indefinitely by staff; only allowed with no active schedule. */
+  Deactivated = "DEACTIVATED",
 }
 
 export enum CargoType {
@@ -779,6 +781,8 @@ export interface ClearanceView {
   /** Customs risk level assigned by GL ET (import; visible to the customer). */
   riskLevel?: string | null;
   riskAssignedAt?: string | null;
+  /** Every risk decision, oldest first; the last entry is the current level. */
+  riskHistory?: import("./contracts").RiskAssignmentRecord[];
   /** Post-arrival additional duty/tax round (import). */
   secondDuty?: import("./contracts").ClearanceSecondDuty | null;
   importReleaseGranted?: boolean;
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 108b45d8b..6ace365ff 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -953,6 +953,9 @@ importers:
       react:
         specifier: ^18.3.1
         version: 18.3.1
+      react-day-picker:
+        specifier: ^9.14.0
+        version: 9.14.0(react@18.3.1)
       react-dom:
         specifier: ^18.3.1
         version: 18.3.1(react@18.3.1)
@@ -22123,6 +22126,14 @@ snapshots:
       date-fns: 3.6.0
       react: 19.2.6
 
+  react-day-picker@9.14.0(react@18.3.1):
+    dependencies:
+      '@date-fns/tz': 1.5.0
+      '@tabby_ai/hijri-converter': 1.0.5
+      date-fns: 4.4.0
+      date-fns-jalali: 4.1.0-0
+      react: 18.3.1
+
   react-day-picker@9.14.0(react@19.2.6):
     dependencies:
       '@date-fns/tz': 1.5.0
diff --git a/ticket-extractor.html b/ticket-extractor.html
new file mode 100644
index 000000000..17be60576
--- /dev/null
+++ b/ticket-extractor.html
@@ -0,0 +1,239 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>EDR Ticket Extractor</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body { font-family: system-ui, sans-serif; background: #f1f5f9; color: #1e293b; min-height: 100vh; padding: 2rem; }
+    h1 { font-size: 1.25rem; font-weight: 700; margin-bottom: 1.5rem; color: #0f172a; }
+    .card { background: #fff; border-radius: 0.75rem; border: 1px solid #e2e8f0; padding: 1.5rem; margin-bottom: 1.5rem; }
+    label { display: block; font-size: 0.8rem; font-weight: 600; color: #475569; margin-bottom: 0.4rem; text-transform: uppercase; letter-spacing: 0.05em; }
+    .hint { font-size: 0.75rem; color: #94a3b8; margin-top: 0.35rem; }
+    .drop-zone {
+      border: 2px dashed #cbd5e1; border-radius: 0.5rem; padding: 2rem;
+      text-align: center; cursor: pointer; color: #94a3b8; font-size: 0.9rem;
+      transition: border-color 0.15s, background 0.15s;
+    }
+    .drop-zone.over { border-color: #10b981; background: #f0fdf4; color: #065f46; }
+    .drop-zone input[type="file"] { display: none; }
+    button {
+      background: #10b981; color: #fff; border: none; border-radius: 0.5rem;
+      padding: 0.65rem 1.5rem; font-size: 0.9rem; font-weight: 600; cursor: pointer; transition: background 0.15s;
+    }
+    button:hover:not(:disabled) { background: #059669; }
+    button:disabled { background: #a7f3d0; cursor: not-allowed; }
+    .btn-secondary { background: #e2e8f0; color: #475569; }
+    .btn-secondary:hover:not(:disabled) { background: #cbd5e1; }
+    .export-btn { background: #6366f1; color: #fff; }
+    .export-btn:hover:not(:disabled) { background: #4f46e5; }
+    .btn-row { display: flex; gap: 0.75rem; align-items: center; margin-top: 1rem; flex-wrap: wrap; }
+    #status { font-size: 0.85rem; color: #64748b; }
+    .summary { display: flex; gap: 1.5rem; flex-wrap: wrap; margin-bottom: 1rem; font-size: 0.85rem; color: #475569; }
+    .summary strong { color: #0f172a; }
+    .table-wrap { overflow-x: auto; }
+    table { width: 100%; border-collapse: collapse; font-size: 0.82rem; }
+    thead tr { background: #f8fafc; border-bottom: 2px solid #e2e8f0; }
+    th { text-align: left; padding: 0.5rem 0.75rem; font-weight: 600; color: #475569; font-size: 0.72rem; text-transform: uppercase; letter-spacing: 0.04em; white-space: nowrap; }
+    td { padding: 0.5rem 0.75rem; border-bottom: 1px solid #f1f5f9; vertical-align: middle; }
+    tr:last-child td { border-bottom: none; }
+    tr:hover td { background: #f8fafc; }
+    #results-section { display: none; }
+  </style>
+</head>
+<body>
+
+<h1>EDR Ticket Extractor</h1>
+
+<div class="card">
+  <label>Tickets JSON File</label>
+  <div class="drop-zone" id="drop-zone" onclick="document.getElementById('file-input').click()">
+    <input type="file" id="file-input" accept=".json" onchange="handleFile(this.files[0])" />
+    Drop <code>tickets.json</code> here or click to browse
+  </div>
+  <p class="hint">Accepts a JSON array of tickets or an object with a <code>tickets</code> key.</p>
+  <div class="btn-row">
+    <button class="btn-secondary" onclick="clearAll()">Clear</button>
+    <button class="export-btn" id="export-btn" onclick="exportCSV()" style="display:none">Export CSV</button>
+    <span id="status"></span>
+  </div>
+</div>
+
+<div class="card" id="results-section">
+  <div class="summary" id="summary"></div>
+  <div class="table-wrap">
+    <table>
+      <thead>
+        <tr>
+          <th>#</th>
+          <th>Ticket No.</th>
+          <th>Booking Ref</th>
+          <th>Passenger</th>
+          <th>Phone</th>
+          <th>Email</th>
+          <th>Journey Type</th>
+          <th>Origin</th>
+          <th>Destination</th>
+          <th>Seat Class</th>
+          <th>Coach</th>
+          <th>Seat</th>
+        </tr>
+      </thead>
+      <tbody id="tbody"></tbody>
+    </table>
+  </div>
+</div>
+
+<script>
+  const FIELDS = [
+    { key: 'ticket_number',   paths: [['ticketNumber']] },
+    { key: 'booking_ref',     paths: [['bookingRef']] },
+    { key: 'passenger_name',  paths: [['passengerName'], ['booking','seats',0,'passengerName']] },
+    { key: 'phone_number',    paths: [['booking','contactPhone'], ['booking','passenger','phone']] },
+    { key: 'email',           paths: [['booking','contactEmail'], ['booking','passenger','email']] },
+    { key: 'journey_type',    paths: [['booking','bookingType']] },
+    { key: 'origin',          paths: [['schedule','originStation','code']] },
+    { key: 'destination',     paths: [['schedule','destinationStation','code']] },
+    { key: 'seat_class',      paths: [['seat','coach','coachType','name']] },
+    { key: 'coach_number',    paths: [['seat','coach','number']] },
+    { key: 'seat_number',     paths: [['seat','seatNumber']] },
+  ];
+
+  let extracted = [];
+
+  function getField(obj, keys) {
+    let cur = obj;
+    for (const k of keys) {
+      if (cur == null) return '';
+      if (Array.isArray(cur) && typeof k === 'number') cur = cur[k];
+      else if (typeof cur === 'object' && k in cur) cur = cur[k];
+      else return '';
+    }
+    return cur ?? '';
+  }
+
+  function extractRow(t) {
+    const row = {};
+    for (const f of FIELDS) {
+      for (const path of f.paths) {
+        const val = getField(t, path);
+        if (val !== '') { row[f.key] = String(val); break; }
+      }
+      if (!row[f.key]) row[f.key] = '';
+    }
+    return row;
+  }
+
+  // Extract complete JSON objects from a truncated array string using brace-depth counting
+  function extractObjects(text) {
+    const results = [];
+    let depth = 0, start = -1, inString = false, escape = false;
+    for (let i = 0; i < text.length; i++) {
+      const ch = text[i];
+      if (escape) { escape = false; continue; }
+      if (ch === '\\' && inString) { escape = true; continue; }
+      if (ch === '"') { inString = !inString; continue; }
+      if (inString) continue;
+      if (ch === '{') {
+        if (depth === 0) start = i;
+        depth++;
+      } else if (ch === '}') {
+        depth--;
+        if (depth === 0 && start !== -1) {
+          try { results.push(JSON.parse(text.slice(start, i + 1))); } catch (_) {}
+          start = -1;
+        }
+      }
+    }
+    return results;
+  }
+
+  window.handleFile = function(file) {
+    if (!file) return;
+    setStatus(`Reading ${file.name}…`);
+    const reader = new FileReader();
+    reader.onload = e => {
+      try {
+        const text = e.target.result.replace(/^\uFEFF/, '');
+        let tickets = [];
+        let parseWarning = '';
+        try {
+          const data = JSON.parse(text);
+          tickets = Array.isArray(data) ? data : (data.tickets ?? []);
+        } catch (_) {
+          // Truncated file: extract complete JSON objects by brace depth
+          tickets = extractObjects(text);
+          parseWarning = `⚠ File was truncated — recovered ${tickets.length} complete record(s).`;
+        }
+        if (!Array.isArray(tickets) || !tickets.length) throw new Error('No ticket records found in the JSON.');
+        extracted = tickets.map(extractRow);
+        renderTable();
+        document.getElementById('results-section').style.display = 'block';
+        document.getElementById('export-btn').style.display = 'inline-block';
+        document.getElementById('summary').innerHTML = `Loaded <strong>${extracted.length}</strong> ticket(s) from <strong>${file.name}</strong>`;
+        setStatus(parseWarning);
+      } catch (err) {
+        setStatus(`Error: ${err.message}`);
+      }
+    };
+    reader.readAsText(file);
+  }
+
+  function renderTable() {
+    const tbody = document.getElementById('tbody');
+    tbody.innerHTML = '';
+    extracted.forEach((row, i) => {
+      const tr = document.createElement('tr');
+      tr.innerHTML = `
+        <td>${i + 1}</td>
+        <td><code>${row.ticket_number || '—'}</code></td>
+        <td><code>${row.booking_ref || '—'}</code></td>
+        <td>${row.passenger_name || '—'}</td>
+        <td>${row.phone_number || '—'}</td>
+        <td>${row.email || '—'}</td>
+        <td>${row.journey_type || '—'}</td>
+        <td>${row.origin || '—'}</td>
+        <td>${row.destination || '—'}</td>
+        <td>${row.seat_class || '—'}</td>
+        <td>${row.coach_number || '—'}</td>
+        <td>${row.seat_number || '—'}</td>`;
+      tbody.appendChild(tr);
+    });
+  }
+
+  window.exportCSV = function() {
+    const header = FIELDS.map(f => f.key).join(',');
+    const lines = extracted.map(row =>
+      FIELDS.map(f => `"${String(row[f.key] ?? '').replace(/"/g, '""')}"`).join(',')
+    );
+    const csv = [header, ...lines].join('\n');
+    const a = document.createElement('a');
+    a.href = URL.createObjectURL(new Blob([csv], { type: 'text/csv' }));
+    a.download = 'tickets_extracted.csv';
+    a.click();
+  }
+
+  window.clearAll = function() {
+    extracted = [];
+    document.getElementById('tbody').innerHTML = '';
+    document.getElementById('results-section').style.display = 'none';
+    document.getElementById('export-btn').style.display = 'none';
+    document.getElementById('file-input').value = '';
+    setStatus('');
+  }
+
+  function setStatus(msg) { document.getElementById('status').textContent = msg; }
+
+  // Drag and drop
+  const dz = document.getElementById('drop-zone');
+  dz.addEventListener('dragover', e => { e.preventDefault(); dz.classList.add('over'); });
+  dz.addEventListener('dragleave', () => dz.classList.remove('over'));
+  dz.addEventListener('drop', e => {
+    e.preventDefault(); dz.classList.remove('over');
+    handleFile(e.dataTransfer.files[0]);
+  });
+</script>
+
+</body>
+</html>