enhance shipment form and booking process

2026-08-26 18:42:49 +00:00 · 2026-07-22 17:25:01 +00:00
parent ef840241c0
commit 5709801590
26 changed files with 1413 additions and 330 deletions
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
@@ -289,6 +289,7 @@ export class ContractBookingService {
      tradeDirection: contract.tradeDirection,
      freightType,
      cargoTypeId: this.resolveCargoTypeId(contract, dto),
+      cargoFreeText: dto.cargoFreeText?.trim() || null,
      isHazardous: this.resolveShipmentHandlingFlag(contract, dto, 'hazardousQuantity'),
      isReefer: this.resolveShipmentHandlingFlag(contract, dto, 'reeferQuantity'),
      cargoTotalWeightVgm: this.resolveBulkTons(dto),
@@ -738,6 +739,7 @@ export class ContractBookingService {
      }
      await this.bookingsRepository.update(booking.id, {
        cargoTypeId: this.resolveCargoTypeId(contract, dto),
+        cargoFreeText: dto.cargoFreeText?.trim() || null,
        cargoTotalWeightVgm: this.resolveBulkTons(dto),
        equipmentReturn: this.resolveShipmentEquipmentReturn(contract, dto),
      } as never);
--- 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
@@ -182,6 +182,13 @@ export class CreateBookingUnderContractDto {
  @Type(() => CreateBulkLineDto)
  bulkLines?: CreateBulkLineDto[];

+  @ApiPropertyOptional({
+    description: 'What the containers carry — captured per booking (container freight).',
+  })
+  @IsOptional()
+  @IsString()
+  cargoFreeText?: string;
+
  @ApiPropertyOptional()
  @IsOptional()
  @IsString()
--- 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
@@ -50,8 +50,11 @@ export class TrainSchedulesRepository extends BaseRepository<TrainSchedule> {
            company: true,
            originYard: true,
            destinationYard: true,
-            bookingContainers: { containerType: true },
-            cargoType: true,
+            // wagonTypes feed grossBookingWeightTons the REAL tare of the
+            // wagon type the booking rides — without them it falls back to
+            // default tares and the workspace gross drifts from the validator.
+            bookingContainers: { containerType: { wagonTypes: true } },
+            cargoType: { wagonTypes: true },
          },
        },
      },
--- 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
@@ -1187,6 +1187,7 @@ describe('BookingBatchService — built-train wagon capacity', () => {
    reserved: Booking[];
    maxWagons?: number;
    routeStops?: string[];
+    yardCountries?: Record<string, string>;
  }) => {
    const schedule = {
      id: scheduleId,
@@ -1218,10 +1219,21 @@ describe('BookingBatchService — built-train wagon capacity', () => {
      find: jest.fn().mockResolvedValue([]),
      update: jest.fn().mockResolvedValue(undefined),
    };
+    const yardRepo = {
+      find: jest
+        .fn()
+        .mockResolvedValue(
+          Object.entries(opts.yardCountries ?? {}).map(([id, country]) => ({
+            id,
+            country,
+          })),
+        ),
+    };
    const dataSource = {
      getRepository: jest.fn((entity: { name?: string }) => {
        if (entity?.name === 'Wagon') return wagonRepo;
        if (entity?.name === 'RouteMilestone') return milestoneRepo;
+        if (entity?.name === 'Yard') return yardRepo;
        return genericRepo;
      }),
      transaction: jest.fn(),
@@ -1264,11 +1276,11 @@ 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.
+  it('is NOT full when only a middle leg is sold and other edges run free (domestic route)', async () => {
+    // Leg-aware allocation (planWagonsWithStock legs) made mid-leg wagons real
+    // capacity on the edges they don't ride: a domestic corridor with cargo
+    // only on m1→m2 still boards bookings on the free first/last edges, so the
+    // window must stay open for them.
    const { service } = buildService({
      physicalWagons: 2,
      routeStops: ['yard-a', 'yard-m1', 'yard-m2', 'yard-b'],
@@ -1277,9 +1289,48 @@ describe('BookingBatchService — built-train wagon capacity', () => {
        reservedBooking('b2', { origin: 'yard-m1', dest: 'yard-m2' }),
      ],
    });
+    await expect(service.isScheduleFull(scheduleId)).resolves.toBe(false);
+  });
+
+  it('is FULL for the trade direction once the border edge is sold out, even with home legs free', async () => {
+    // Export b→c holds every wagon of the border crossing: no further export
+    // can board anywhere (they all must ride that edge), so the window closes —
+    // while intercity keeps booking the free a→b leg through the per-leg budget.
+    const { service } = buildService({
+      physicalWagons: 2,
+      routeStops: ['yard-a', 'yard-b', 'yard-dj'],
+      yardCountries: {
+        'yard-a': 'ETHIOPIA',
+        'yard-b': 'ETHIOPIA',
+        'yard-dj': 'DJIBOUTI',
+      },
+      reserved: [
+        reservedBooking('b1', { origin: 'yard-b', dest: 'yard-dj' }),
+        reservedBooking('b2', { origin: 'yard-b', dest: 'yard-dj' }),
+      ],
+    });
    await expect(service.isScheduleFull(scheduleId)).resolves.toBe(true);
  });

+  it('is NOT full while the border edge still has room, even with a home leg sold out', async () => {
+    // Intercity rode a→b on both wagons; the border edge b→dj is still free,
+    // so exports can still board — the window stays open.
+    const { service } = buildService({
+      physicalWagons: 2,
+      routeStops: ['yard-a', 'yard-b', 'yard-dj'],
+      yardCountries: {
+        'yard-a': 'ETHIOPIA',
+        'yard-b': 'ETHIOPIA',
+        'yard-dj': 'DJIBOUTI',
+      },
+      reserved: [
+        reservedBooking('b1', { origin: 'yard-a', dest: 'yard-b' }),
+        reservedBooking('b2', { origin: 'yard-a', dest: 'yard-b' }),
+      ],
+    });
+    await expect(service.isScheduleFull(scheduleId)).resolves.toBe(false);
+  });
+
  it('reports over-allocation when the consist is trimmed below committed bookings', async () => {
    const { service } = buildService({
      physicalWagons: 1,
--- 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
@@ -24,9 +24,9 @@ import {
 import { Booking } from '../bookings/entities/booking.entity';
 import { BookingsRepository } from '../bookings/bookings.repository';
 import { BookingPricingService } from '../bookings/booking-pricing.service';
-import { Locomotive } from '../locomotives/entities/locomotive.entity';
 import { formatRouteLabel } from '../routes/entities/route.entity';
 import { RouteMilestone } from '../routes/entities/route-milestone.entity';
+import { Yard } from '../rule-engine/entities/yard.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
 import { TrainScheduleBooking } from '../train-schedules/entities/train-schedule-booking.entity';
 import { TrainSchedulesRepository } from '../train-schedules/train-schedules.repository';
@@ -60,11 +60,14 @@ import {
  DEFAULT_WAGONS_PER_BOOKING,
 } from "./booking-batch.constants";
 import {
+  LocomotiveLimits,
  WagonTypeDimensions,
+  bookingCargoTons,
  bookingGrossWeightTons,
  deriveTrainCapacityFromLocomotive,
  sizePartialOfferWagons,
  trainHardCaps,
+  trainSetLocomotiveLimits,
  wagonTypeDimensionsFromEntity,
 } from './train-capacity.util';
 import { WagonType } from '../wagon-types/entities/wagon-type.entity';
@@ -677,7 +680,7 @@ export class BookingBatchService implements OnModuleInit {
      const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
        candidate.id,
      );
-      const locomotive = schedule?.trainSet?.locomotive;
+      const locomotive = trainSetLocomotiveLimits(schedule?.trainSet);
      if (!schedule || !locomotive) continue;
      const limits = await this.capacityLimits(locomotive);
      const budget = await this.remainingBudget(schedule, limits, wagonDims);
@@ -825,7 +828,7 @@ export class BookingBatchService implements OnModuleInit {
      const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
        candidate.id,
      );
-      const locomotive = schedule?.trainSet?.locomotive;
+      const locomotive = trainSetLocomotiveLimits(schedule?.trainSet);
      if (!schedule || !locomotive) continue;
      const limits = await this.capacityLimits(locomotive);
      const budget = await this.remainingBudget(schedule, limits, wagonDims);
@@ -895,7 +898,7 @@ export class BookingBatchService implements OnModuleInit {
      const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
        candidate.id,
      );
-      const locomotive = schedule?.trainSet?.locomotive;
+      const locomotive = trainSetLocomotiveLimits(schedule?.trainSet);
      if (!schedule || !locomotive) continue;
      const limits = await this.capacityLimits(locomotive);
      const budget = await this.remainingBudget(schedule, limits, wagonDims);
@@ -937,7 +940,7 @@ export class BookingBatchService implements OnModuleInit {
    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(
      target.scheduleId,
    );
-    const locomotive = schedule?.trainSet?.locomotive;
+    const locomotive = trainSetLocomotiveLimits(schedule?.trainSet);
    if (!schedule || !locomotive) return false;
    const wagonDims = await this.loadWagonDims();
    const limits = await this.capacityLimits(locomotive);
@@ -1034,7 +1037,7 @@ export class BookingBatchService implements OnModuleInit {
      }
      const schedule =
        await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
-      const locomotive = schedule?.trainSet?.locomotive;
+      const locomotive = trainSetLocomotiveLimits(schedule?.trainSet);
      if (!schedule || !locomotive) {
        throw new ConflictException(
          "Export train is no longer available for reservation",
@@ -1351,7 +1354,7 @@ export class BookingBatchService implements OnModuleInit {
      };
    });

-    const loco = s.trainSet?.locomotive ?? null;
+    const loco = trainSetLocomotiveLimits(s.trainSet);

    // The board renders ONE booking window — the schedule's own frozen window
    // (windowOpensAt/windowClosesAt + phase deadlines returned below). Bookings
@@ -1411,10 +1414,12 @@ export class BookingBatchService implements OnModuleInit {
          trainName: s.trainSet.train.trainName ?? null,
        }
        : null,
+      // Identity from the primary (legacy) locomotive; limit figures from the
+      // whole set's effective minimum — what the fill engine actually spends.
      locomotive: loco
        ? {
-          code: loco.code,
-          name: loco.name ?? null,
+          code: s.trainSet?.locomotive?.code ?? '',
+          name: s.trainSet?.locomotive?.name ?? null,
          maxPullWeightTons: Number(loco.maxPullWeightTons),
          maxTrainLengthMeters: Number(loco.maxTrainLengthMeters),
        }
@@ -1464,7 +1469,7 @@ export class BookingBatchService implements OnModuleInit {
      weightTons: number;
      lengthMeters: number;
    }>,
-    loco: Locomotive | null,
+    loco: LocomotiveLimits | null,
    maxWagons: number | null,
  ): BatchBoardSchedule["capacity"] {
    const allocated = items.filter((i) => i.state === "ALLOCATED");
@@ -1499,7 +1504,7 @@ export class BookingBatchService implements OnModuleInit {
    s: TrainSchedule,
    items: BatchBoardBooking[],
  ): BatchBoardSchedule {
-    const loco = s.trainSet?.locomotive ?? null;
+    const loco = trainSetLocomotiveLimits(s.trainSet);

    return {
      scheduleId: s.id,
@@ -1531,10 +1536,12 @@ export class BookingBatchService implements OnModuleInit {
          trainName: s.trainSet.train.trainName ?? null,
        }
        : null,
+      // Identity from the primary (legacy) locomotive; limit figures from the
+      // whole set's effective minimum — what the fill engine actually spends.
      locomotive: loco
        ? {
-          code: loco.code,
-          name: loco.name ?? null,
+          code: s.trainSet?.locomotive?.code ?? '',
+          name: s.trainSet?.locomotive?.name ?? null,
          maxPullWeightTons: Number(loco.maxPullWeightTons),
          maxTrainLengthMeters: Number(loco.maxTrainLengthMeters),
        }
@@ -1600,7 +1607,7 @@ export class BookingBatchService implements OnModuleInit {
    const schedule =
      await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
    if (!schedule || !this.isFillable(schedule)) return 0;
-    const locomotive = schedule.trainSet?.locomotive;
+    const locomotive = trainSetLocomotiveLimits(schedule.trainSet);
    if (!schedule.trainSetId || !locomotive) {
      this.logger.warn(
        `Schedule ${scheduleId} has no locomotive/train set — skipped.`,
@@ -1827,7 +1834,7 @@ export class BookingBatchService implements OnModuleInit {
    for (const id of scheduleIds) {
      const schedule =
        await this.trainSchedulesRepository.findByIdWithFullGraph(id);
-      const locomotive = schedule?.trainSet?.locomotive;
+      const locomotive = trainSetLocomotiveLimits(schedule?.trainSet);
      if (!schedule || !schedule.trainSetId || !locomotive) {
        this.logger.warn(
          `Schedule ${id} has no locomotive/train set — skipped.`,
@@ -2469,7 +2476,7 @@ export class BookingBatchService implements OnModuleInit {
  } | null> {
    const schedule =
      await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
-    const locomotive = schedule?.trainSet?.locomotive;
+    const locomotive = trainSetLocomotiveLimits(schedule?.trainSet);
    if (!schedule || !locomotive) return null;
    const wagonDims = await this.loadWagonDims();
    const limits = await this.capacityLimits(locomotive);
@@ -3114,8 +3121,7 @@ export class BookingBatchService implements OnModuleInit {
    const containers = (b: Booking): number =>
      (b.bookingContainers ?? []).reduce((sum, c) => sum + Number(c.quantity ?? 0), 0);
    const totalContainers = containers(primary) + containers(partner);
-    const cargoTons =
-      Number(primary.cargoTotalWeightVgm ?? 0) + Number(partner.cargoTotalWeightVgm ?? 0);
+    const cargoTons = bookingCargoTons(primary) + bookingCargoTons(partner);

    // Consolidation shares TEU slots, never rated payload: the pair still needs
    // enough wagons to carry its combined cargo, so the weight axis bounds the
@@ -3222,7 +3228,7 @@ export class BookingBatchService implements OnModuleInit {
    const byLength = containerWagonsForLines(booking.bookingContainers ?? []);

    const capacityTons = this.dimsFor(booking, wagonDims).capacityTons;
-    const cargoTons = Number(booking.cargoTotalWeightVgm ?? 0);
+    const cargoTons = bookingCargoTons(booking);
    const byWeight =
      cargoTons > 0 && capacityTons > 0 ? Math.ceil(cargoTons / capacityTons) : 0;

@@ -3243,7 +3249,7 @@ export class BookingBatchService implements OnModuleInit {
    return {
      wagons,
      weightTons: bookingGrossWeightTons(
-        Number(booking.cargoTotalWeightVgm ?? 0),
+        bookingCargoTons(booking),
        wagons,
        dims.tareWeightTons,
      ),
@@ -3270,7 +3276,7 @@ export class BookingBatchService implements OnModuleInit {
   * caps deliberately do not apply here (a mis-set global row once capped
   * every train at 14m and no export booking could board).
   */
-  private async capacityLimits(locomotive: Locomotive): Promise<TrainLimits> {
+  private async capacityLimits(locomotive: LocomotiveLimits): Promise<TrainLimits> {
    const wagonTypes = await this.loadWagonTypeDimensions();
    const derived = deriveTrainCapacityFromLocomotive(
      {
@@ -3304,7 +3310,7 @@ export class BookingBatchService implements OnModuleInit {
   */
  private async syncScheduleMaxWagons(
    schedule: TrainSchedule,
-    locomotive: Locomotive,
+    locomotive: LocomotiveLimits,
  ): Promise<void> {
    const physicalWagons = await this.builtTrainWagonCount(schedule);
    const maxWagons =
@@ -3605,14 +3611,14 @@ export class BookingBatchService implements OnModuleInit {
  }

  /**
-   * Built train: FULL when every physical wagon slot is taken — the consist is
-   * the capacity, weight/length were settled at build time.
-   * No built train: FULL on ANY capacity axis — out of wagon slots, or out of
-   * pull weight / train length for even one more loaded wagon. The old
-   * slot-only check let a weight-bound train (PW2: weight binds at 37 wagons =
-   * 3522.4T of 3500+90T, slots bind at 44) cycle its booking window forever
-   * instead of finalizing — 7 phantom slots kept it "not full" while nothing
-   * could board.
+   * FULL is DIRECTIONAL: the schedule's trade direction is full when the
+   * border-crossing edge (which every export/import must ride) can't take one
+   * more minimal wagon on any axis — slots for built trains (the consist is
+   * the capacity, weight/length settled at build), all three axes otherwise
+   * (PW2: weight binds at 37 wagons = 3522.4T of 3500+90T, slots bind at 44).
+   * Home-side legs may still run empty; intercity ride-alongs keep filling
+   * them via the per-leg budget and never consult this flag. Domestic routes
+   * (no border) are full only when every edge is closed.
   */
  async isScheduleFull(scheduleId: string): Promise<boolean> {
    const schedule =
@@ -3663,48 +3669,69 @@ 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;
-    const locomotive = schedule.trainSet?.locomotive;
-    if (!locomotive) return false; // no weight/length limits to bind against
+    // "Full" means full FOR THE TRAIN'S TRADE DIRECTION. Every export and
+    // every import must cross the ET↔DJ border edge, so once that edge can't
+    // take one more minimal wagon the booking window may close — even while
+    // home-side legs still run empty. Intercity ride-alongs never consult this
+    // flag; they keep booking the free legs through the per-leg budget.
+    // A single-country (domestic) corridor has no mandatory edge, so it is
+    // full only when EVERY edge is closed on some axis.
    const wagonDims = await this.loadWagonDims();
-    const limits = await this.capacityLimits(locomotive);
+    const physicalWagons = await this.builtTrainWagonCount(schedule);
+    let limits: TrainLimits;
+    if (physicalWagons != null) {
+      // The consist is the capacity; weight/length were settled at build time.
+      // remainingBudget swaps in the physical wagon count per edge itself.
+      limits = {
+        base: {
+          wagons: physicalWagons,
+          weightTons: Number.POSITIVE_INFINITY,
+          lengthMeters: Number.POSITIVE_INFINITY,
+        },
+        tolerance: { weightTons: 0, lengthMeters: 0 },
+      };
+    } else {
+      const locomotive = trainSetLocomotiveLimits(schedule.trainSet);
+      // No loco, no built train: only the slot axis exists to bind against.
+      if (!locomotive) return (await this.remainingWagons(schedule)) <= 0;
+      limits = await this.capacityLimits(locomotive);
+    }
    const budget = await this.remainingBudget(schedule, limits, wagonDims);
-    return budget.isExhausted(this.minPerWagonNeed(wagonDims));
+    const minNeed = this.minPerWagonNeed(wagonDims);
+    const border = await this.borderLeg(budget.stops);
+    if (border) {
+      return !budget.fits(
+        {
+          wagons: 1,
+          weightTons: minNeed.grossWeightTons,
+          lengthMeters: minNeed.lengthMeters,
+        },
+        border,
+      );
+    }
+    return budget.isExhausted(minNeed);
  }

  /**
-   * 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.
+   * The corridor's single border-crossing edge (last home-country stop → first
+   * far-country stop), or null when every stop is in one country. This is the
+   * edge every EXPORT and IMPORT booking must ride, whichever sub-corridor it
+   * books — which makes it the train's directional fullness gauge.
   */
-  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;
+  private async borderLeg(stops: string[]): Promise<CorridorLeg | null> {
+    if (stops.length < 2) return null;
+    const yards = await this.dataSource
+      .getRepository(Yard)
+      .find({ where: { id: In(stops) } });
+    const countryOf = new Map(yards.map((y) => [y.id, y.country]));
+    const first = countryOf.get(stops[0]);
+    if (!first) return null;
+    const crossIdx = stops.findIndex((id) => {
+      const country = countryOf.get(id);
+      return country != null && country !== first;
+    });
+    if (crossIdx <= 0) return null;
+    return { fromEdge: crossIdx - 1, toEdge: crossIdx };
  }

  /**
--- a/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/fleet-plan.util.ts
@@ -1,3 +1,4 @@
+import { bookingCargoTons } from './train-capacity.util';
 import type { Booking } from '../bookings/entities/booking.entity';
 import type { WagonType } from '../wagon-types/entities/wagon-type.entity';
 import {
@@ -187,5 +188,5 @@ export function summarizeFleetWarnings(
 }

 export function totalAssignedWeight(bookings: Booking[]): number {
-  return roundTons(bookings.reduce((sum, b) => sum + Number(b.cargoTotalWeightVgm ?? 0), 0));
+  return roundTons(bookings.reduce((sum, b) => sum + bookingCargoTons(b), 0));
 }
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.spec.ts
@@ -7,6 +7,7 @@ import {
  grossWagonWeightTons,
  minLocomotiveLimits,
  sizePartialOfferWagons,
+  trainSetLocomotiveLimits,
 } from './train-capacity.util';

 describe('train-capacity.util', () => {
@@ -205,6 +206,37 @@ describe('train-capacity.util', () => {
    expect(limits?.overageToleranceTons).toBe(20);
  });

+  it('ignores unconfigured (null) tolerances instead of zeroing the set (S-2026-00024)', () => {
+    // LOCO-019 had 90T tolerance, LOCO-020 had none configured: the set must
+    // keep the 90, not collapse to 0 and reject 3547.6T on a 3500T train.
+    const limits = minLocomotiveLimits([
+      { maxPullWeightTons: 3500, maxTrainLengthMeters: 760, overageToleranceTons: 90 },
+      { maxPullWeightTons: 3500, maxTrainLengthMeters: 760, overageToleranceTons: null },
+    ]);
+    expect(limits?.overageToleranceTons).toBe(90);
+    // All unconfigured → no tolerance.
+    const none = minLocomotiveLimits([
+      { maxPullWeightTons: 3500, maxTrainLengthMeters: 760 },
+    ]);
+    expect(none?.overageToleranceTons).toBe(0);
+  });
+
+  it('trainSetLocomotiveLimits prefers link rows and falls back to the legacy single loco', () => {
+    const l1 = { maxPullWeightTons: 3500, maxTrainLengthMeters: 760, overageToleranceTons: 90 };
+    const l2 = { maxPullWeightTons: 3600, maxTrainLengthMeters: 700, overageToleranceTons: null };
+    expect(
+      trainSetLocomotiveLimits({ locomotive: null, locomotives: [{ locomotive: l1 }, { locomotive: l2 }] }),
+    ).toEqual({
+      maxPullWeightTons: 3500,
+      maxTrainLengthMeters: 700,
+      overageToleranceTons: 90,
+      overageToleranceMeters: 0,
+    });
+    expect(trainSetLocomotiveLimits({ locomotive: l1 })?.maxPullWeightTons).toBe(3500);
+    expect(trainSetLocomotiveLimits(null)).toBeNull();
+    expect(trainSetLocomotiveLimits({ locomotive: null, locomotives: [] })).toBeNull();
+  });
+
  describe('sizePartialOfferWagons', () => {
    it('sizes a bulk split by the WEIGHT axis when the pull limit binds, not wagon slots', () => {
      // The 3500T-train scenario: two 1000T bookings boarded gross (each 15 PW2
--- a/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/train-capacity.util.ts
@@ -86,6 +86,27 @@ function num(value: unknown, fallback = 0): number {
  return Number.isFinite(n) ? n : fallback;
 }

+/**
+ * Cargo tons of a booking: the stored VGM total when present, else the sum of
+ * its container lines (quantity × VGM per unit). The portal's container flow
+ * stores per-line VGM and leaves `cargoTotalWeightVgm` at 0 — reading the
+ * total alone made every such booking weigh only its tare.
+ */
+export function bookingCargoTons(booking: {
+  cargoTotalWeightVgm?: number | string | null;
+  bookingContainers?: Array<{
+    quantity?: number | null;
+    vgmPerUnitTons?: number | string | null;
+  }> | null;
+}): number {
+  const total = num(booking.cargoTotalWeightVgm);
+  if (total > 0) return total;
+  return (booking.bookingContainers ?? []).reduce(
+    (sum, line) => sum + num(line.quantity) * num(line.vgmPerUnitTons),
+    0,
+  );
+}
+
 /** Gross weight of one loaded wagon: it hauls itself plus its cargo. */
 export function grossWagonWeightTons(slot: Pick<ConsistSlot, 'tareWeightTons' | 'cargoTons'>): number {
  return num(slot.tareWeightTons) + num(slot.cargoTons);
@@ -260,11 +281,34 @@ export function minLocomotiveLimits(
  };
 }

-function minConfigured(values: Array<number | string | null | undefined>): number {
+function minConfigured(values: Array<number | null | undefined>): number {
  const configured = values.filter((v) => v != null).map((v) => num(v));
  return configured.length ? Math.min(...configured) : 0;
 }

+/**
+ * Effective limits for a whole train set: min across its linked locomotives,
+ * falling back to the legacy single `locomotive` column for sets created
+ * before multi-loco support. Null when the set has no locomotive at all.
+ */
+export function trainSetLocomotiveLimits(
+  trainSet?: {
+    locomotive?: LocomotiveLimits | null;
+    locomotives?: Array<{ locomotive?: LocomotiveLimits | null }> | null;
+  } | null,
+): LocomotiveLimits | null {
+  if (!trainSet) return null;
+  const linked = (trainSet.locomotives ?? [])
+    .map((link) => link.locomotive)
+    .filter((l): l is LocomotiveLimits => Boolean(l));
+  const pool = linked.length
+    ? linked
+    : trainSet.locomotive
+      ? [trainSet.locomotive]
+      : [];
+  return minLocomotiveLimits(pool);
+}
+
 /** Per-booking train length from wagon count and freight-specific wagon type length. */
 export function bookingTrainLengthMeters(
  freightType: string | null | undefined,
--- 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
@@ -122,6 +122,7 @@ import {
  roundTons,
  sumWagonsRequired,
  type TrainLimitConfig,
+  maxEdgeConsistUsage,
  validateContainerPlacements,
  validateMixedTrainLimitsPerEdge,
  type ContainerPlacementInput,
@@ -130,9 +131,12 @@ import {
 import { deriveScheduleDirection } from './derive-schedule-direction.util';
 import { pickLowestFreeNumber, pickTrainNumberPool } from './train-number.util';
 import {
+  bookingCargoTons,
  deriveTrainCapacityFromLocomotive,
  minLocomotiveLimits,
+  trainSetLocomotiveLimits,
  wagonTypeDimensionsFromEntity,
+  LocomotiveLimits,
  WagonTypeDimensions,
 } from './train-capacity.util';
 import {
@@ -1706,25 +1710,36 @@ export class TrainSchedulingService {
          relations: { wagonType: true },
        })
      : null;
-    const planTareTons = consistWagons
+    const planTareTons = roundTons(
+      wagonPlan.reduce((sum, slot) => sum + Number(slot.tareWeightTons ?? 0), 0),
+    );
+    const consistTareTons = consistWagons
      ? roundTons(
          consistWagons.reduce(
            (sum, wagon) => sum + Number(wagon.wagonType?.tareWeightTons ?? 0),
            0,
          ),
        )
-      : roundTons(
-          wagonPlan.reduce((sum, slot) => sum + Number(slot.tareWeightTons ?? 0), 0),
+      : planTareTons;
+    // The pull limit binds on the HEAVIEST LEG, not the whole-route sum —
+    // disjoint legs (intercity Gelan→Adama + export Adama→Doraleh) are never
+    // hauled at the same time. Coupled-but-unplanned wagons ride every edge,
+    // so their tare rides on top of the binding edge.
+    const emptyConsistTareTons = Math.max(0, consistTareTons - planTareTons);
+    const edgeUsage = maxEdgeConsistUsage(
+      wagonPlan,
+      await this.stopYardsForSchedule(schedule),
    );
-    const grossWeightTons = roundTons(totalWeightTons + planTareTons);
+    const grossWeightTons = roundTons(edgeUsage.grossWeightTons + emptyConsistTareTons);
    if (!dto.forceAssign && weightCapWithOverage < grossWeightTons) {
      throw new BadRequestException(
-        `Train set locomotives cannot pull ${grossWeightTons}T gross (${totalWeightTons}T cargo + ${planTareTons}T wagon tare)`,
+        `Train set locomotives cannot pull ${grossWeightTons}T gross on the heaviest leg (limit ${roundTons(weightCapWithOverage)}T incl. tolerance)`,
      );
    }
-    if (!dto.forceAssign && lengthCapWithOverage < totalLengthMeters) {
+    const maxEdgeLengthMeters = roundTons(edgeUsage.lengthMeters);
+    if (!dto.forceAssign && lengthCapWithOverage < maxEdgeLengthMeters) {
      throw new BadRequestException(
-        `Train set locomotives cannot support ${totalLengthMeters}m`,
+        `Train set locomotives cannot support ${maxEdgeLengthMeters}m`,
      );
    }

@@ -4086,9 +4101,6 @@ 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),
    );
@@ -4096,12 +4108,13 @@ export class TrainSchedulingService {
    const totalLengthMeters = roundTons(
      wagonPlan.reduce((sum, w) => sum + w.lengthMeters, 0),
    );
-    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]);
-      }
-    }
+    // Weight/length limits are enforced PER EDGE by validateMixedTrainLimitsPerEdge
+    // above — the whole-route totals here are informational (summary) only. The
+    // locomotive checks below also compare the heaviest single edge: a train is
+    // never heavier than its heaviest leg, so disjoint legs must not be summed.
+    const edgeUsage = maxEdgeConsistUsage(wagonPlan, stops);
+    const maxEdgeGrossTons = roundTons(edgeUsage.grossWeightTons);
+    const maxEdgeLengthMeters = roundTons(edgeUsage.lengthMeters);

    let assignedLocomotives: Locomotive[] = [];
    if (targetScheduleId) {
@@ -4124,9 +4137,9 @@ export class TrainSchedulingService {
      if (
        setLimits &&
        (setLimits.maxPullWeightTons + (Number(setLimits.overageToleranceTons) || 0) <
-          grossWeightTons ||
+          maxEdgeGrossTons ||
          setLimits.maxTrainLengthMeters + (Number(setLimits.overageToleranceMeters) || 0) <
-            totalLengthMeters)
+            maxEdgeLengthMeters)
      ) {
        pushLimit([
          'Assigned locomotives cannot support the total train weight and length',
@@ -4145,9 +4158,9 @@ export class TrainSchedulingService {
        !inServiceLocomotives.some(
          (l) =>
            Number(l.maxPullWeightTons) + (Number(l.overageToleranceTons) || 0) >=
-              grossWeightTons &&
+              maxEdgeGrossTons &&
            Number(l.maxTrainLengthMeters) + (Number(l.overageToleranceMeters) || 0) >=
-              totalLengthMeters,
+              maxEdgeLengthMeters,
        )
      ) {
        pushLimit(['No locomotive can support the total train weight and length']);
@@ -4206,10 +4219,7 @@ export class TrainSchedulingService {
      maxTrainLengthMeters?: number;
      maxWagonsPerTrain?: number;
    },
-    locomotive?: Pick<
-      Locomotive,
-      'maxPullWeightTons' | 'maxTrainLengthMeters' | 'overageToleranceTons' | 'overageToleranceMeters'
-    >,
+    locomotive?: LocomotiveLimits | null,
  ): Promise<Required<TrainLimitConfig>> {
    const row = await this.loadGlobalRulesRow();
    const configured = this.configService?.get<{
@@ -6517,7 +6527,7 @@ export class TrainSchedulingService {
    >,
    tareDims: Awaited<ReturnType<TrainSchedulingService['loadWagonTareDims']>>,
  ): number {
-    const cargo = Number(booking.cargoTotalWeightVgm ?? 0);
+    const cargo = bookingCargoTons(booking);
    const fallback =
      booking.freightType === 'BULK' ? tareDims.bulk : tareDims.container;
    // Same first-configured-type resolution the batch engine's dimsFor uses.
@@ -6883,6 +6893,18 @@ export class TrainSchedulingService {
      // Ordered corridor stops (route milestones; falls back to the two
      // endpoints) — lets the UI draw per-segment occupancy and label legs.
      stops: this.mapScheduleStops(schedule),
+      // Gross ceiling the validator holds each leg to: the set's weakest
+      // locomotive pull limit plus its overage tolerance. Booking weightTons
+      // above are gross too, so the strip can sum them per leg against this.
+      maxGrossWeightTons: (() => {
+        const setLimits = trainSetLocomotiveLimits(schedule.trainSet);
+        return setLimits
+          ? roundTons(
+              Number(setLimits.maxPullWeightTons) +
+                (Number(setLimits.overageToleranceTons) || 0),
+            )
+          : null;
+      })(),
      // True when the wagon plan above is served from the frozen snapshot (schedule
      // is dispatched/arrived/cancelled) rather than the live joins — the UI can badge
      // it "historical" and skip re-pin affordances.
@@ -6978,7 +7000,10 @@ export class TrainSchedulingService {
      originStationId: schedule.originStationId,
      destinationStationId: schedule.destinationStationId,
    };
-    const limits = await this.resolveTrainLimitConfig(undefined, schedule.trainSet.locomotive);
+    const limits = await this.resolveTrainLimitConfig(
+      undefined,
+      trainSetLocomotiveLimits(schedule.trainSet),
+    );

    const validation = await this.validateBookingsForScheduling(
      previewDto,
@@ -7104,7 +7129,7 @@ export class TrainSchedulingService {
    };
    const limits = await this.resolveTrainLimitConfig(
      undefined,
-      schedule.trainSet.locomotive,
+      trainSetLocomotiveLimits(schedule.trainSet),
    );

    let validation: Awaited<ReturnType<TrainSchedulingService['validateBookingsForScheduling']>>;
@@ -7648,7 +7673,7 @@ export class TrainSchedulingService {
    };
    const limits = await this.resolveTrainLimitConfig(
      undefined,
-      schedule.trainSet.locomotive,
+      trainSetLocomotiveLimits(schedule.trainSet),
    );

    let validation: Awaited<ReturnType<TrainSchedulingService['validateBookingsForScheduling']>>;
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.spec.ts
@@ -9,6 +9,7 @@ import {
  containerWagonsForLines,
  expandBookingContainerUnits,
  expandContainerItems,
+  maxEdgeConsistUsage,
  roundTons,
  sumWagonsRequired,
  validate20ftContainerRules,
@@ -279,3 +280,54 @@ describe('containerWagonsForLines — TEU-aware, ceil booking total once', () =>
    expect(containerWagonsForLines([])).toBe(0);
  });
 });
+
+describe('maxEdgeConsistUsage — the binding edge, not the whole-route sum', () => {
+  const slot = (
+    tare: number,
+    cargo: number,
+    length: number,
+    board?: string | null,
+    alight?: string | null,
+  ) =>
+    ({
+      tareWeightTons: tare,
+      assignedWeightTons: cargo,
+      lengthMeters: length,
+      boardYardId: board ?? null,
+      alightYardId: alight ?? null,
+    }) as never;
+
+  const stops = ['a', 'b', 'c'];
+
+  it('does not sum disjoint legs: intercity a→b + export b→c', () => {
+    const plan = [
+      slot(24, 65, 14, null, 'b'), // intercity, rides a→b only
+      slot(24, 65, 14, 'b', null), // export, rides b→c only
+    ];
+    // Each edge carries one slot: 89T gross / 14m — never 178T.
+    expect(maxEdgeConsistUsage(plan, stops)).toEqual({
+      grossWeightTons: 89,
+      lengthMeters: 14,
+    });
+  });
+
+  it('sums overlapping legs on their shared edge (the S-2026-00024 shape)', () => {
+    // 20 intercity a→b wagons + 20 export a→c wagons, 23.94T tare, 64.75T cargo:
+    // shared edge a→b carries all 40 slots = 3547.6T gross.
+    const plan = [
+      ...Array.from({ length: 20 }, () => slot(23.94, 64.75, 14, null, 'b')),
+      ...Array.from({ length: 20 }, () => slot(23.94, 64.75, 14, null, null)),
+    ];
+    const usage = maxEdgeConsistUsage(plan, stops);
+    expect(usage.grossWeightTons).toBeCloseTo(3547.6, 1);
+    expect(usage.lengthMeters).toBe(560);
+  });
+
+  it('degrades to whole-train totals on a two-stop route', () => {
+    const plan = [slot(24, 65, 14), slot(24, 65, 14)];
+    expect(maxEdgeConsistUsage(plan, ['a', 'b'])).toEqual({
+      grossWeightTons: 178,
+      lengthMeters: 28,
+    });
+  });
+});
--- a/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/wagon-plan.util.ts
@@ -539,15 +539,9 @@ export function validateMixedTrainLimitsPerEdge(
  stops: string[],
 ): string[] {
  if (stops.length <= 2) return validateMixedTrainLimits(wagonPlan, wagonTypes, limits);
-  const lastIdx = stops.length - 1;
-  const spans = wagonPlan.map((slot) => {
-    const from = slot.boardYardId ? stops.indexOf(slot.boardYardId) : 0;
-    const to = slot.alightYardId ? stops.indexOf(slot.alightYardId) : lastIdx;
-    // A yard missing from the stop list keeps the slot on the whole route.
-    return { from: from >= 0 ? from : 0, to: to > 0 ? to : lastIdx };
-  });
+  const spans = slotSpans(wagonPlan, stops);
  const violations = new Set<string>();
-  for (let edge = 0; edge < lastIdx; edge += 1) {
+  for (let edge = 0; edge < stops.length - 1; edge += 1) {
    const active = wagonPlan.filter(
      (_, i) => spans[i].from <= edge && edge < spans[i].to,
    );
@@ -559,6 +553,52 @@ export function validateMixedTrainLimitsPerEdge(
  return [...violations];
 }

+/** Per-slot stop-index spans; a yard missing from the stop list keeps the slot on the whole route. */
+function slotSpans(
+  wagonPlan: WagonPlanSlot[],
+  stops: string[],
+): Array<{ from: number; to: number }> {
+  const lastIdx = stops.length - 1;
+  return wagonPlan.map((slot) => {
+    const from = slot.boardYardId ? stops.indexOf(slot.boardYardId) : 0;
+    const to = slot.alightYardId ? stops.indexOf(slot.alightYardId) : lastIdx;
+    return { from: from >= 0 ? from : 0, to: to > 0 ? to : lastIdx };
+  });
+}
+
+/**
+ * The corridor's binding edge: gross tons (tare + assigned cargo) and length
+ * summed over only the slots riding each edge, maxed across edges. This is the
+ * figure a locomotive pull/length limit must be compared against — a train is
+ * never heavier than its heaviest single leg, so summing disjoint legs
+ * (intercity Gelan→Adama + export Adama→Doraleh) over-reports the train.
+ * Two stops or fewer degrade to the whole-train totals.
+ */
+export function maxEdgeConsistUsage(
+  wagonPlan: WagonPlanSlot[],
+  stops: string[],
+): { grossWeightTons: number; lengthMeters: number } {
+  const totals = (slots: WagonPlanSlot[]) => ({
+    grossWeightTons: slots.reduce(
+      (sum, w) =>
+        sum + Number(w.tareWeightTons ?? 0) + Number(w.assignedWeightTons ?? 0),
+      0,
+    ),
+    lengthMeters: slots.reduce((sum, w) => sum + Number(w.lengthMeters ?? 0), 0),
+  });
+  if (stops.length <= 2) return totals(wagonPlan);
+  const spans = slotSpans(wagonPlan, stops);
+  const usage = { grossWeightTons: 0, lengthMeters: 0 };
+  for (let edge = 0; edge < stops.length - 1; edge += 1) {
+    const active = totals(
+      wagonPlan.filter((_, i) => spans[i].from <= edge && edge < spans[i].to),
+    );
+    usage.grossWeightTons = Math.max(usage.grossWeightTons, active.grossWeightTons);
+    usage.lengthMeters = Math.max(usage.lengthMeters, active.lengthMeters);
+  }
+  return usage;
+}
+
 export function validate20ftContainerRules(
  units: ContainerUnitRow[],
  placements: ContainerPlacementInput[],
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -269,6 +269,8 @@ export default function GlCreateBookingForm() {
  const [scheduledDate, setScheduledDate] = useState("");
  const [contractRouteId, setContractRouteId] = useState<string | null>(null);
  const [notes, setNotes] = useState("");
+  // What the containers carry — captured per booking (moved off the contract).
+  const [cargoDescription, setCargoDescription] = useState("");
  const [containerLines, setContainerLines] = useState<ContainerLineDraft[]>([]);
  const [bulk, setBulk] = useState<BulkDraft>({
    cargoWeightTons: "",
@@ -459,6 +461,10 @@ export default function GlCreateBookingForm() {
      );
    };
    setPrefilled(true);
+    // Rebook carries the expired booking's cargo description forward.
+    if (copyFromBooking.cargoFreeText) {
+      setCargoDescription(copyFromBooking.cargoFreeText);
+    }
    setContainerLines(
      lines.map((c) => {
        const qty = Math.max(1, c.quantity);
@@ -705,14 +711,23 @@ export default function GlCreateBookingForm() {

  const lineErrors = useMemo<LineErrors[]>(() => {
    if (!isContainer || !contract) return [];
-    return containerLines.map((line) => {
+    // A line can be 0 (the contract covers both sizes; a booking may only need
+    // one) but the booking as a whole needs at least one container — anchor
+    // that error on the first line's quantity so it renders in the field.
+    const totalQty = containerLines.reduce(
+      (sum, l) => sum + Math.max(0, Number(l.quantity) || 0),
+      0,
+    );
+    return containerLines.map((line, idx) => {
      const errs: LineErrors = {};
      const qty = Number(line.quantity || 0);
      if (line.quantity.trim() === "") {
        errs.quantity = "Quantity is required.";
-      } else if (Number.isNaN(qty) || qty < 1) {
-        errs.quantity = "At least 1.";
-      } else if (line.units.length < qty) {
+      } else if (Number.isNaN(qty) || qty < 0) {
+        errs.quantity = "Enter 0 or more.";
+      } else if (idx === 0 && totalQty < 1) {
+        errs.quantity = "Book at least one container (either size).";
+      } else if (qty >= 1 && line.units.length < qty) {
        errs.units = `Enter details for all ${qty} container(s).`;
      }
      if (contract.isHazardous) {
@@ -789,6 +804,11 @@ export default function GlCreateBookingForm() {
  const routeError =
    multiRoute && !contractRouteId ? "Select a route." : undefined;

+  const cargoDescriptionError =
+    isContainer && !cargoDescription.trim()
+      ? "Describe the cargo carried in the containers."
+      : undefined;
+
  const cargoValid = isContainer
    ? lineErrors.every(
        (e) =>
@@ -800,7 +820,8 @@ export default function GlCreateBookingForm() {
      ) &&
      unitErrors.every((line) =>
        line.every((e) => !e.containerNumber && !e.vgmTons),
-      )
+      ) &&
+      !cargoDescriptionError
    : !bulkErrors.quantity && !bulkErrors.hazardous && !bulkErrors.reefer;

  const formValid = cargoValid && !hasOdd20ft && !dateError && !routeError;
@@ -827,6 +848,8 @@ export default function GlCreateBookingForm() {
    };

    if (isContainer) {
+      // What the containers carry — captured per booking, not on the contract.
+      if (cargoDescription.trim()) payload.cargoFreeText = cargoDescription.trim();
      payload.containers = containerLines
        .filter((l) => Number(l.quantity) >= 1)
        .map((l) => ({
@@ -1245,6 +1268,19 @@ export default function GlCreateBookingForm() {
              )}
              {remainderNotice}
              <ContractCapacityNotice contractId={contract.id} isContainer />
+              <Textarea
+                label="Cargo description *"
+                description="What do the containers carry on this shipment?"
+                placeholder="e.g. Electronics, garments, machinery spare parts…"
+                value={cargoDescription}
+                onChange={(e) => setCargoDescription(e.currentTarget.value)}
+                error={showErrors ? cargoDescriptionError : undefined}
+                radius={10}
+                autosize
+                minRows={2}
+                maxRows={4}
+                styles={fieldStyles}
+              />
              {containerLines.length === 0 ? (
                <Text fz="sm" c="dimmed">
                  This contract has no container sizes in scope.
@@ -1264,7 +1300,7 @@ export default function GlCreateBookingForm() {
                        type="number"
                        onKeyDown={blockNegative}
                        label="Quantity *"
-                        min={1}
+                        min={0}
                        value={line.quantity}
                        error={
                          showErrors
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/scheduleVisuals.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/scheduleVisuals.tsx
@@ -287,6 +287,8 @@ export type SegmentStripBooking = {
  destinationYardId?: string | null;
  tradeDirection?: string | null;
  wagonsRequired?: number | null;
+  /** GROSS tons (cargo + tare of the booking's wagons), as the API sends it. */
+  weightTons?: number | null;
 };

 /**
@@ -300,10 +302,13 @@ export function SegmentOccupancyStrip({
  stops,
  bookings,
  maxWagons,
+  maxGrossTons,
 }: {
  stops: Array<{ yardId: string; label: string }>;
  bookings: SegmentStripBooking[];
  maxWagons?: number | null;
+  /** Loco pull ceiling incl. tolerance — per-leg gross is measured against it. */
+  maxGrossTons?: number | null;
 }) {
  if (stops.length < 2) return null;
  const lastIdx = stops.length - 1;
@@ -312,6 +317,7 @@ export function SegmentOccupancyStrip({
  const segments = stops.slice(0, -1).map((stop, edge) => {
    let cargo = 0;
    let intercity = 0;
+    let grossTons = 0;
    for (const b of bookings) {
      const from = (b.originYardId ? indexOf.get(b.originYardId) : undefined) ?? 0;
      const to =
@@ -322,8 +328,15 @@ export function SegmentOccupancyStrip({
      const wagons = Number(b.wagonsRequired) || 1;
      if (b.tradeDirection === "DOMESTIC") intercity += wagons;
      else cargo += wagons;
+      grossTons += Number(b.weightTons) || 0;
    }
-    return { from: stop, to: stops[edge + 1], cargo, intercity };
+    return {
+      from: stop,
+      to: stops[edge + 1],
+      cargo,
+      intercity,
+      grossTons: Math.round(grossTons * 10) / 10,
+    };
  });

  const cap = Number(maxWagons) || null;
@@ -393,6 +406,22 @@ export function SegmentOccupancyStrip({
                  </Text>
                ) : null}
              </Text>
+              {seg.grossTons > 0 ? (
+                <Text
+                  size="xs"
+                  ta="center"
+                  fw={600}
+                  c={
+                    maxGrossTons != null && seg.grossTons > maxGrossTons
+                      ? "red.7"
+                      : "dimmed"
+                  }
+                  style={{ whiteSpace: "nowrap" }}
+                >
+                  {seg.grossTons}
+                  {maxGrossTons != null ? ` / ${maxGrossTons}` : ""} T gross
+                </Text>
+              ) : null}
            </Stack>
            {i === segments.length - 1 ? (
              <Stack gap={2} align="center" justify="flex-end" style={{ minWidth: 0 }}>
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
@@ -935,6 +935,7 @@ export default function TrainScheduleV2DetailPage() {
                    stops={schedule.stops ?? []}
                    bookings={schedule.bookings ?? []}
                    maxWagons={schedule.maxWagons}
+                    maxGrossTons={schedule.maxGrossWeightTons}
                  />
                ) : (
                  <Box maw={340}>
--- a/apps/edr-freight-web/backoffice/src/types/booking.ts
+++ b/apps/edr-freight-web/backoffice/src/types/booking.ts
@@ -169,6 +169,8 @@ export interface BookingDetail {
  contractType: string;
  freightType: "CONTAINER" | "BULK";
  tradeDirection: string;
+  /** What the containers carry / bulk commodity label — entered at booking time. */
+  cargoFreeText?: string | null;
  cargoTotalWeightVgm: number;
  isHazardous: boolean;
  consolidationPartnerId?: string | null;
--- a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
+++ b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
@@ -640,6 +640,8 @@ export interface TrainScheduleDetail {
  }>;
  /** Ordered corridor stops (route milestones) — for per-segment occupancy. */
  stops?: Array<{ yardId: string; label: string }>;
+  /** Loco pull ceiling incl. overage tolerance — per-leg gross is held to it. */
+  maxGrossWeightTons?: number | null;
  warnings?: string[];
 }

--- a/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewContractPage.tsx
@@ -38,6 +38,7 @@ import {
 } from "react-router-dom";
 import useAuth from "@/hooks/useAuth";
 import {
+  CONTAINER_SIZES,
  CONTRACT_STEPS,
  ContractFormInputValues,
  contractFormSchema,
@@ -537,15 +538,15 @@ export default function NewContractPage({
    const isContainer = data.cargoType === "container";
    const isGeneral = data.contractKind === "general_contract";

-    // Cargo scope rows — no quantities (doc §5.4). Container: one row per enabled
-    // size; bulk: a single commodity row. Both GENERAL and ONE_TIME are uncapped
-    // (quantityCap omitted → NULL): the customer books repeatedly against a
-    // GENERAL contract until its validity expires.
+    // Cargo scope rows — no quantities (doc §5.4). Container: ALWAYS both sizes
+    // (rates quoted for both; per-booking quantities can zero a size out) and no
+    // description — that moved to booking time. Bulk: a single commodity row.
+    // Both GENERAL and ONE_TIME are uncapped (quantityCap omitted → NULL): the
+    // customer books repeatedly against a GENERAL contract until its validity
+    // expires.
    const cargoScope: Freight.CreateContractCargoScopeDto[] = isContainer
-      ? data.enabledContainerSizes.map((size) => ({
+      ? CONTAINER_SIZES.map((size) => ({
        containerSize: size,
-        // Required cargo description — what the containers carry.
-        cargoFreeText: data.cargoFreeText.trim() || undefined,
      }))
      : [
        {
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
@@ -346,6 +346,10 @@ function NewShipmentBookingForm({
      // Equipment return is a container concern — bulk keeps the contract default.
      ...(isContainer
        ? {
+            // What the containers carry — captured per booking, not on the contract.
+            ...(values.cargoDescription?.trim()
+              ? { cargoFreeText: values.cargoDescription.trim() }
+              : {}),
            containers: values.containers
              .filter((l) => Number(l.quantity) >= 1)
              .map((l) => ({
@@ -1295,6 +1299,26 @@ function CargoStep({
          )}
          {remainderNotice}
          <ContractCapacityNotice contractId={contract.id} isContainer />
+          <Controller
+            name="cargoDescription"
+            control={form.control}
+            render={({ field, fieldState }) => (
+              <Textarea
+                label="Cargo description *"
+                description="What do the containers carry on this shipment?"
+                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}
+              />
+            )}
+          />
          {lines.map((line, index) => (
            <ContainerLineEditor
              key={line.containerSize}
@@ -1648,7 +1672,7 @@ function ContainerLineEditor({
              type="number"
              onKeyDown={blockNegative}
              label="Quantity *"
-              min={1}
+              min={0}
              error={fieldState.error?.message}
              radius={10}
              styles={fieldStyles}
--- 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
@@ -58,12 +58,9 @@ export function contractToFormValues(

  const scope = contract.cargoScope ?? [];

-  // Container scope: one row per enabled size, with per-size caps for GENERAL.
-  const enabledContainerSizes = isContainer
-    ? scope
-        .map((s) => s.containerSize)
-        .filter((s): s is string => Boolean(s))
-    : [];
+  // Container scope: contracts now always cover both sizes — force both even
+  // for older single-size drafts so resubmitting upgrades them.
+  const enabledContainerSizes = isContainer ? ["20ft", "40ft"] : [];
  const containerSizeCaps: Record<string, number> = {};
  if (isContainer && isGeneral) {
    for (const s of scope) {
@@ -119,10 +116,9 @@ export function contractToFormValues(
      enabledContainerSizes as ContractFormInputValues["enabledContainerSizes"],
    containerSizeCaps,
    cargoTypePath,
-    // 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) ?? "",
+    // Bulk commodity free-text only — the container cargo description is
+    // captured per booking now, not on the contract.
+    cargoFreeText: (isContainer ? "" : bulkRow?.cargoFreeText) ?? "",
    bulkQuantityCap:
      isGeneral && bulkRow?.quantityCap != null ? bulkRow.quantityCap : 0,
    isHazardous: contract.isHazardous,
--- 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
@@ -160,8 +160,9 @@ export const contractFormSchema = z

    // ── Cargo SCOPE (no quantities) ──
    cargoType: z.enum(["container", "bulk"], "Select a cargo type."),
-    // Container scope: the enabled sizes (min 1). Each becomes a
-    // contract_cargo_scope row.
+    // Container scope: ALWAYS both sizes — the contract covers 20ft and 40ft
+    // (both rates shown); the customer picks quantities per booking, where a
+    // size can be 0. No picker in the UI; kept for review display/prefill.
    enabledContainerSizes: z.array(z.enum(CONTAINER_SIZES)).default([]),
    // GENERAL only: per-size container quantity cap (total bookable over the
    // validity window). Keyed by size; must be > 0 for every enabled size
@@ -222,24 +223,8 @@ export const contractFormSchema = z
        message: "Intercity contracts are priced in ETB.",
      });
    }
-    if (data.cargoType === "container") {
-      // Container scope: at least one enabled size.
-      if (data.enabledContainerSizes.length === 0) {
-        ctx.addIssue({
-          code: "custom",
-          path: ["enabledContainerSizes"],
-          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.",
-        });
-      }
-    }
+    // Container scope needs no validation: both sizes are always in scope and
+    // the cargo description moved to booking time.
    if (data.cargoType === "bulk") {
      // Bulk scope: a commodity is required.
      if (!data.cargoTypePath[0]) {
@@ -280,7 +265,7 @@ export const initialContractFormValues: DeepPartial<ContractFormValues> = {
  customsClearingAgent: "",

  cargoType: "container",
-  enabledContainerSizes: [],
+  enabledContainerSizes: [...CONTAINER_SIZES],
  containerSizeCaps: {},
  cargoTypePath: [],
  cargoFreeText: "",
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-contract-form/step1-contract-type.tsx
@@ -152,10 +152,11 @@ export function Step1ContractType({
      contract.freightType === "BULK" ? "bulk" : "container",
    );
    const scope = contract.cargoScope ?? [];
-    const sizes = scope
-      .map((s) => s.containerSize)
-      .filter((s): s is "20ft" | "40ft" => s === "20ft" || s === "40ft");
-    if (sizes.length > 0) form.setValue("enabledContainerSizes", sizes);
+    // Contracts always cover both sizes now — even when renewing an older
+    // single-size contract.
+    if (contract.freightType !== "BULK") {
+      form.setValue("enabledContainerSizes", ["20ft", "40ft"]);
+    }
    const bulkScope = scope.find((s) => s.cargoTypeId);
    if (bulkScope?.cargoTypeId) {
      // Find the parent group for this commodity so the cascader prefills.
--- 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,6 +1,6 @@
 import { useEffect, useMemo, useRef } from "react";
 import { Controller, type UseFormReturn } from "react-hook-form";
-import { Check, Container, Flame, RotateCcw, Snowflake } from "lucide-react";
+import { Container, Flame, RotateCcw, Snowflake } from "lucide-react";
 import {
  Box,
  Group,
@@ -9,33 +9,15 @@ import {
  Stack,
  Switch,
  Text,
-  Textarea,
-  UnstyledButton,
 } from "@mantine/core";
 import type { Freight } from "@edr/types";
 import {
+  CONTAINER_SIZES,
  ContractFormInputValues,
  type ContractFormValues,
 } from "./schema";
 import { fieldStyles, SelectField, StepLabel } from "./shared";

-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 = [
  { value: "container", label: "Containerized (20ft / 40ft)" },
  { value: "bulk", label: "General / Bulk cargo" },
@@ -128,11 +110,17 @@ 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.
+                // cargoFreeText is the bulk commodity label — clear it so text
+                // never carries across types (container description is captured
+                // at booking time now).
                form.setValue("cargoFreeText", "", { shouldDirty: true });
                if (v === "container") {
                  form.setValue("cargoTypePath", [], { shouldDirty: true });
+                  // Contracts always cover BOTH sizes; quantities are chosen per
+                  // booking (a size can be 0 there).
+                  form.setValue("enabledContainerSizes", [...CONTAINER_SIZES], {
+                    shouldDirty: true,
+                  });
                } else {
                  form.setValue("enabledContainerSizes", [], {
                    shouldDirty: true,
@@ -152,74 +140,47 @@ export function Step3CargoScope({

      </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. */}
+      {/* Container scope: the contract always covers BOTH sizes and quotes both
+          rates. Quantities (a size can be 0) and the cargo description are
+          captured at booking time. */}
      {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>
-            );
+        <Group
+          gap={13}
+          align="center"
+          wrap="nowrap"
+          px={16}
+          py={13}
+          style={{
+            borderRadius: 14,
+            border: "1.5px solid #CDEBDD",
+            background: "#F6FBF8",
          }}
-        />
-      )}
-
-      {/* 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}
-            />
-          )}
-        />
+        >
+          <Box
+            style={{
+              width: 38,
+              height: 38,
+              borderRadius: 11,
+              flexShrink: 0,
+              display: "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              background: "#EAF6EC",
+              color: "#1E7B34",
+            }}
+          >
+            <Container size={18} />
+          </Box>
+          <Box>
+            <Text fz={14} fw={700} c="#10202F">
+              20ft &amp; 40ft containers covered
+            </Text>
+            <Text fz={12} c="#6B7C8E" style={{ lineHeight: 1.4 }}>
+              This contract quotes rates for both sizes. You choose the
+              quantities on each booking — either size can be 0.
+            </Text>
+          </Box>
+        </Group>
      )}

      {/* Bulk scope: a single commodity (cargo type path). No tonnage. */}
@@ -330,85 +291,6 @@ 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,
--- 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
@@ -57,10 +57,13 @@ const containerUnitSchema = z.object({

 const containerLineSchema = z.object({
  containerSize: z.enum(["20ft", "40ft"]),
+  // 0 is allowed: the contract covers both sizes, so a booking that only needs
+  // one size zeroes the other line out. At least one line must be ≥ 1
+  // (enforced in the superRefine).
  quantity: z
    .string()
    .refine((v) => v.trim().length > 0, "Quantity is required.")
-    .refine((v) => !Number.isNaN(Number(v)) && Number(v) >= 1, "At least 1."),
+    .refine((v) => !Number.isNaN(Number(v)) && Number(v) >= 0, "Enter 0 or more."),
  hazardousQuantity: z.string().default("0"),
  reeferQuantity: z.string().default("0"),
  returnQuantity: z.string().default("0"),
@@ -74,6 +77,8 @@ const shipmentFormBase = z.object({
  // unloading. Seeded from the contract's equipment return; bulk ignores it.
  withReturn: z.boolean().default(false),
  containers: z.array(containerLineSchema).default([]),
+  // What the containers carry — captured per booking (moved off the contract).
+  cargoDescription: z.string().default(""),
  cargoWeightTons: z.string().default(""),
  itemCount: z.string().default(""),
  bulkHazardousQuantity: z.string().default("0"),
@@ -92,6 +97,28 @@ export function createShipmentFormSchema(ctx: ShipmentValidationContext) {
    }

    if (ctx.isContainer) {
+      // Containerized cargo must say WHAT is inside — required per booking.
+      if (!data.cargoDescription.trim()) {
+        refineCtx.addIssue({
+          code: "custom",
+          path: ["cargoDescription"],
+          message: "Describe the cargo carried in the containers.",
+        });
+      }
+      // Both sizes are always in contract scope and a line can be 0 — but the
+      // booking as a whole needs at least one container. Anchor the error on
+      // the first line's quantity so it renders in the field.
+      const totalQty = data.containers.reduce(
+        (sum, l) => sum + Math.max(0, Number(l.quantity) || 0),
+        0,
+      );
+      if (data.containers.length > 0 && totalQty < 1) {
+        refineCtx.addIssue({
+          code: "custom",
+          path: ["containers", 0, "quantity"],
+          message: "Book at least one container (either size).",
+        });
+      }
      // Container numbers must be unique within this shipment (front-end only —
      // the DB column is intentionally not unique). Duplicates block submit and
      // price generation since both run through this same schema validation.
@@ -243,6 +270,7 @@ export const initialShipmentFormValues: DeepPartial<ShipmentFormValues> = {
  scheduledDate: "",
  withReturn: false,
  containers: [],
+  cargoDescription: "",
  cargoWeightTons: "",
  itemCount: "",
  bulkHazardousQuantity: "0",
@@ -257,6 +285,7 @@ export const shipmentStepFields: Record<
  0: ["contractRouteId"],
  1: [
    "containers",
+    "cargoDescription",
    "cargoWeightTons",
    "itemCount",
    "bulkHazardousQuantity",
--- a/e2e/freight/cypress/e2e/flows/segment_weight.cy.ts
+++ b/e2e/freight/cypress/e2e/flows/segment_weight.cy.ts
@@ -0,0 +1,634 @@
+/**
+ * Segment weight & tolerance journeys — per-edge capacity on one corridor
+ * (Mojo Dry Port → Dire Dawa Yard → Nagad Terminal), two dedicated
+ * trains departing the same day (seed-segment-weight.sql):
+ *
+ *   TRN-SEG-W "tolerance train" — 240T pull; one loco carries a 90T overage
+ *   tolerance, the second has NONE CONFIGURED (the S-2026-00024 regression
+ *   pair: the set's tolerance must stay 90, not collapse to 0).
+ *
+ *     1. 130T wheat Mojo→Djibouti  → 179.6T gross (2 CW4) on both legs
+ *     2. intercity 2×20ft VGM 24 Mojo→Dire → 70.4T gross (1 NW5); the shared
+ *        Mojo→Dire leg hits 250T — OVER the 240T base, inside the 330T
+ *        ceiling. Wagon allocation must succeed (allocation is what silently
+ *        failed on S-2026-00024: PAID + SCHEDULED, zero allocations).
+ *     3. a second identical ride-along → 320.4T, still inside the ceiling —
+ *        the tolerance admits whole bookings repeatedly until spent
+ *     4. the schedule detail strip shows the per-leg gross vs the ceiling
+ *
+ *   TRN-SEG-F "border-full train" — 200T pull, no tolerance, 4 NW5.
+ *
+ *     5. 8×20ft export boarding at DIRE (sub-corridor) commits all 4 wagons
+ *        on the border edge (W's border edge only has 2 free, so FCFS lands
+ *        it on F) → the window goes FULL for the trade direction
+ *     6. the FULL train still accepts an intercity ride-along Mojo→Dire on
+ *        its free home leg (the old whole-train sum — 169.6 + 70.4 = 240T >
+ *        200T pull — rejected the accept outright; per-edge math admits it).
+ *        Wagon ALLOCATION of that shared wagon is a known gap: physical
+ *        pinning is slot-exclusive, so the test asserts accept + link only.
+ *
+ * Contracts are seeded FULLY_EXECUTED straight into SQL (stamped references,
+ * re-runnable) — contract lifecycle is covered by the other flow specs; this
+ * spec is about the scheduling engine. Run against a fresh e2e stack: the
+ * trains' capacity math assumes empty consists.
+ *
+ * Sequential steps of one journey — retries off (steps are not idempotent).
+ */
+
+const customer = "user@gmail.com";
+const companyTin = "0102030405"; // seed-company.sql
+const opsStaff = "operation@edr.local";
+
+// Own corridor (…→ Nagad, not Djibouti Port): other specs schedule TRN-E2E-1
+// on the Djibouti Port route, and an earlier-departing same-day train there
+// would steal these FCFS bookings.
+const ORIGIN_YARD = "Mojo Dry Port";
+const MID_YARD = "Dire Dawa Yard";
+const PORT_YARD = "Nagad Terminal, Djibouti";
+const TRAIN_W = "TRN-SEG-W";
+const TRAIN_F = "TRN-SEG-F";
+
+const stamp = String(Date.now());
+const isoNumber = (prefix: string, offset: number) =>
+  `${prefix}${String(Number(stamp.slice(-7)) + offset).padStart(7, "0")}`;
+
+// A ONE_TIME contract is spent after one booking, so every run seeds a fresh
+// set with stamped references. Lookups go by SUFFIX + newest row: Cypress
+// re-evaluates the spec bundle on cross-origin reloads, so a module-scope
+// stamp drifts between tests and must never key a lookup.
+const REF = {
+  exportMojo: "EXP1",
+  exportDire: "EXP2",
+  ic1: "IC1",
+  ic2: "IC2",
+  ic3: "IC3",
+} as const;
+const stampedRef = (suffix: string) => `CTR-SEG-${stamp}-${suffix}`;
+
+/** Both trains depart just past the 24h export lead — windows open in minutes. */
+const DEPART_W = new Date(Date.now() + 24 * 3_600_000 + 4 * 60_000);
+const DEPART_F = new Date(Date.now() + 24 * 3_600_000 + 7 * 60_000);
+
+const apiUrl = () => Cypress.env("apiUrl") as string;
+
+/** Seed one FULLY_EXECUTED ONE_TIME contract (contract + route + cargo scope). */
+function seedContract(opts: {
+  suffix: string;
+  reference: string;
+  direction: "EXPORT" | "DOMESTIC";
+  freight: "CONTAINER" | "BULK";
+  originCode: string;
+  destCode: string;
+}) {
+  cy.task("db:query", {
+    sql: `WITH c AS (
+            INSERT INTO freight.contracts
+              (reference, company_id, company_profile_id, contract_kind,
+               trade_direction, freight_type, service_type_id, payment_currency,
+               status, fully_executed_at, contract_valid_from,
+               contract_valid_until, contract_summary)
+            SELECT $1, comp.id,
+                   -- bookings.company_profile_id is NOT NULL and inherits from
+                   -- the contract: exporter profile for exports, any active
+                   -- profile otherwise.
+                   (SELECT p.id FROM freight.company_profiles p
+                     WHERE p.company_id = comp.id AND p.deleted_at IS NULL
+                     ORDER BY CASE
+                       WHEN $2 = 'EXPORT' AND p.type = 'exporter' THEN 0
+                       ELSE 1
+                     END
+                     LIMIT 1),
+                   'ONE_TIME', $2, $3,
+                   (SELECT st.id FROM freight.service_types st ORDER BY st.created_at LIMIT 1),
+                   'ETB', 'FULLY_EXECUTED', now(), now() - interval '1 day',
+                   now() + interval '60 days', 'E2E segment-weight fixture contract'
+            FROM freight.companies comp
+            WHERE comp.tin = $4
+              -- before() re-runs on Cypress reloads: skip when this run
+              -- already seeded a fresh, still-unbooked contract for the
+              -- suffix, so lookups keep pointing at one stable row.
+              AND NOT EXISTS (
+                SELECT 1 FROM freight.contracts c2
+                WHERE c2.reference LIKE 'CTR-SEG-%-' || $7
+                  AND c2.deleted_at IS NULL
+                  AND c2.created_at > now() - interval '15 minutes'
+                  AND NOT EXISTS (
+                    SELECT 1 FROM freight.bookings b2 WHERE b2.contract_id = c2.id
+                  )
+              )
+            RETURNING id
+          ), r AS (
+            INSERT INTO freight.contract_routes
+              (contract_id, origin_yard_id, destination_yard_id, sort_order)
+            SELECT c.id, o.id, d.id, 0 FROM c
+            JOIN freight.yards o ON o.code = $5
+            JOIN freight.yards d ON d.code = $6
+            RETURNING id
+          )
+          INSERT INTO freight.contract_cargo_scope
+            (contract_id, container_size, cargo_type_id, cargo_free_text)
+          SELECT c.id,
+                 CASE WHEN $3 = 'CONTAINER' THEN '20ft' END,
+                 CASE WHEN $3 = 'BULK' THEN
+                   (SELECT ct.id FROM freight.cargo_types ct WHERE ct.code = 'E2E_WHEAT' LIMIT 1)
+                 END,
+                 'E2E segment-weight cargo'
+          FROM c`,
+    params: [
+      opts.reference,
+      opts.direction,
+      opts.freight,
+      companyTin,
+      opts.originCode,
+      opts.destCode,
+      opts.suffix,
+    ],
+  });
+}
+
+/** Newest seeded contract for a suffix — stamp-agnostic (see REF). */
+function dbContractId(suffix: string) {
+  return cy
+    .task<{ rows: Array<{ id: string }> }>("db:query", {
+      sql: `SELECT id FROM freight.contracts
+            WHERE reference LIKE 'CTR-SEG-%-' || $1
+            ORDER BY created_at DESC LIMIT 1`,
+      params: [suffix],
+    })
+    .then(({ rows }) => {
+      expect(rows, `seeded contract *-${suffix}`).to.have.length(1);
+      return cy.wrap(rows[0].id, { log: false });
+    });
+}
+
+type BookingRow = {
+  id: string;
+  reference: string;
+  status: string;
+  scheduling_status: string;
+  train_schedule_id: string | null;
+  payment_deadline: string | null;
+};
+
+/** The (only) booking under this run's seeded contract for a suffix. */
+function withBooking(suffix: string, fn: (b: BookingRow) => void) {
+  cy.task<{ rows: BookingRow[] }>("db:query", {
+    sql: `SELECT b.id, b.reference, b.status, b.scheduling_status,
+                 b.train_schedule_id, b.payment_deadline
+          FROM freight.bookings b
+          JOIN freight.contracts ct ON ct.id = b.contract_id
+          WHERE ct.reference LIKE 'CTR-SEG-%-' || $1
+          ORDER BY b.created_at DESC LIMIT 1`,
+    params: [suffix],
+  }).then(({ rows }) => {
+    expect(rows, `booking under *-${suffix}`).to.have.length(1);
+    fn(rows[0]);
+  });
+}
+
+type ScheduleRow = {
+  id: string;
+  booking_window_status: string;
+  window_closes_at: string;
+};
+
+/** The live schedule riding a given built train on the NAGAD corridor. */
+function dbScheduleFor(trainCode: string) {
+  return cy.task<{ rows: ScheduleRow[] }>("db:query", {
+    sql: `SELECT ts.id, ts.booking_window_status, ts.window_closes_at
+          FROM freight.train_schedules ts
+          JOIN freight.train_sets se ON se.id = ts.train_set_id
+          JOIN freight.trains t ON t.id = se.train_id
+          JOIN freight.yards d ON d.id = ts.destination_station_id
+          WHERE t.code = $1 AND d.code = 'NAGAD' AND ts.deleted_at IS NULL
+          ORDER BY ts.created_at DESC LIMIT 1`,
+    params: [trainCode],
+  });
+}
+
+function withSchedule(trainCode: string, fn: (s: ScheduleRow) => void) {
+  dbScheduleFor(trainCode).then(({ rows }) => {
+    expect(rows, `schedule for ${trainCode}`).to.have.length(1);
+    fn(rows[0]);
+  });
+}
+
+function fill(label: string | RegExp, value: string) {
+  cy.contains("label", label)
+    .invoke("attr", "for")
+    .then((id) => {
+      cy.get(`[id="${id}"]`).clear({ force: true }).type(value, { force: true });
+    });
+}
+
+/** Pick the departure day on the booking form's inline calendar. */
+function pickShipmentDay(date: Date) {
+  cy.contains(/available day/, { timeout: 30000 }).should("exist");
+  const day = String(date.getDate());
+  cy.get("button:not(:disabled)", { timeout: 15000 })
+    .contains(new RegExp(`^${day}$`))
+    .click({ force: true });
+}
+
+/** Create one schedule from a built train, departing at the given moment. */
+function createSchedule(trainCode: string, departure: Date) {
+  cy.visit("/dashboard/operations/train-scheduling-v2");
+  cy.contains("button", "New schedule", { timeout: 20000 }).click();
+  cy.contains("Create train schedule", { timeout: 15000 }).should("be.visible");
+  cy.mantineSelect(/^Route$/, /Nagad/);
+  const local = new Date(departure.getTime() - departure.getTimezoneOffset() * 60000)
+    .toISOString()
+    .slice(0, 16);
+  cy.get('.mantine-Modal-content input[type="datetime-local"]')
+    .clear({ force: true })
+    .type(local, { force: true });
+  cy.mantineSelect(/^Train$/, new RegExp(trainCode));
+  cy.get(".mantine-Modal-content").contains("button", "Create").click();
+  cy.location("pathname", { timeout: 30000 }).should(
+    "match",
+    /\/dashboard\/operations\/train-scheduling-v2\/.+/,
+  );
+}
+
+/** Ops accepts a booking's operation request from the booking-requests page. */
+function acceptOperationRequest(contractRef: string) {
+  cy.loginBackoffice(opsStaff);
+  withBooking(contractRef, (b) => cy.visit(`/dashboard/booking-requests/${b.id}`));
+  cy.contains("button", /Accept operation|^Accept$/, { timeout: 20000 }).click();
+  cy.contains("Accept operation request?", { timeout: 15000 }).should("be.visible");
+  cy.get(".mantine-Modal-content").contains("button", /^Accept$/).click();
+  cy.get(".mantine-Modal-content", { timeout: 30000 }).should("not.exist");
+}
+
+/** Book 2×20ft VGM 24T each under a seeded DOMESTIC contract (48T cargo, 1 NW5). */
+function bookIntercityPair(contractRef: string, isoOffset: number) {
+  cy.loginPortal(customer);
+  dbContractId(contractRef).then((id) => cy.visitPortal(`/contracts/${id}/bookings/new`));
+  cy.contains("New Shipment Booking", { timeout: 20000 }).should("be.visible");
+
+  fill(/^Quantity/, "2");
+  cy.get('input[placeholder*="MSCU"]', { timeout: 15000 }).should("have.length", 2);
+  cy.get('input[placeholder*="MSCU"]').eq(0).type(isoNumber("MSCU", isoOffset));
+  cy.get('input[placeholder*="MSCU"]').eq(1).type(isoNumber("TCLU", isoOffset + 1));
+  cy.get('input[placeholder*="24.5"]').each(($input) => {
+    cy.wrap($input).clear({ force: true }).type("24", { force: true });
+  });
+  cy.contains("Shipment day").should("not.exist");
+
+  cy.contains("button", "Review price & book").should("not.be.disabled").click();
+  cy.contains("Confirm shipment price", { timeout: 30000 }).should("be.visible");
+  cy.contains("button", "Confirm & book").click();
+  cy.location("pathname", { timeout: 30000 }).should("match", /^\/bookings\/.+/);
+}
+
+/** Accept a waiting intercity booking from a schedule's ride-along panel. */
+function acceptRideAlong(trainCode: string, contractRef: string) {
+  cy.loginBackoffice(opsStaff);
+  withSchedule(trainCode, (s) =>
+    cy.visit(`/dashboard/operations/train-scheduling-v2/${s.id}`),
+  );
+  cy.contains('[role="tab"]', "Workspace", { timeout: 30000 }).click();
+  cy.contains("Intercity ride-along", { timeout: 30000 }).should("exist");
+  withBooking(contractRef, (b) => {
+    cy.contains("tr", b.reference, { timeout: 30000 })
+      .find('input[type="checkbox"]')
+      .check({ force: true });
+    cy.contains("button", /Accept .*onto this train/).click();
+    cy.contains("Awaiting payment", { timeout: 30000 }).should("exist");
+  });
+}
+
+/** Staff mark-paid (no mounted UI button), then wait for wagon allocation. */
+function markPaidAndAssertAllocated(contractRef: string) {
+  withBooking(contractRef, (b) => {
+    cy.apiLogin(opsStaff).then(({ token }) => {
+      cy.request({
+        method: "POST",
+        url: `${apiUrl()}/api/train-scheduling/bookings/${b.id}/mark-paid`,
+        headers: { Authorization: `Bearer ${token}` },
+      })
+        .its("status")
+        .should("be.oneOf", [200, 201]);
+    });
+  });
+  withBooking(contractRef, (b) => {
+    expect(b.status).to.eq("PAID");
+    expect(b.scheduling_status).to.eq("SCHEDULED");
+
+    // Wagon allocation runs async after allocate() — poll for its rows.
+    // Zero allocations with a PAID/SCHEDULED booking is exactly the
+    // S-2026-00024 failure shape this spec guards against.
+    const waitForAllocation = (attempt: number) => {
+      cy.task<{ rows: Array<{ n: string }> }>("db:query", {
+        sql: `SELECT count(*) AS n FROM freight.wagon_booking_allocations
+              WHERE booking_id = $1 AND deleted_at IS NULL`,
+        params: [b.id],
+      }).then(({ rows }) => {
+        if (Number(rows[0].n) > 0) return;
+        expect(attempt, `wagon allocations for ${contractRef}`).to.be.lessThan(20);
+        cy.wait(2000).then(() => waitForAllocation(attempt + 1));
+      });
+    };
+    waitForAllocation(0);
+  });
+}
+
+describe(
+  "segment weight: per-edge caps, loco tolerance, directional FULL",
+  { retries: 0 },
+  () => {
+    before(() => {
+      cy.task("db:seedFile", "seed-intercity.sql");
+      cy.task("db:seedFile", "seed-export.sql");
+      cy.task("db:seedFile", "seed-segment-weight.sql");
+      seedContract({
+        suffix: REF.exportMojo,
+        reference: stampedRef(REF.exportMojo),
+        direction: "EXPORT",
+        freight: "BULK",
+        originCode: "MOJO",
+        destCode: "NAGAD",
+      });
+      seedContract({
+        suffix: REF.exportDire,
+        reference: stampedRef(REF.exportDire),
+        direction: "EXPORT",
+        freight: "CONTAINER",
+        originCode: "DIRE_DAWA",
+        destCode: "NAGAD",
+      });
+      for (const ref of [REF.ic1, REF.ic2, REF.ic3]) {
+        seedContract({
+          suffix: ref,
+          reference: stampedRef(ref),
+          direction: "DOMESTIC",
+          freight: "CONTAINER",
+          originCode: "MOJO",
+          destCode: "DIRE_DAWA",
+        });
+      }
+    });
+
+    // ── Infrastructure ───────────────────────────────────────────────────────
+
+    it("operations ensures the export route exists", () => {
+      cy.loginBackoffice(opsStaff);
+      cy.task<{ rows: Array<{ n: string }> }>("db:query", {
+        sql: `SELECT count(*) AS n
+              FROM freight.routes r
+              JOIN freight.yards o ON o.id = r.origin_yard_id AND o.code = 'MOJO'
+              JOIN freight.yards d ON d.id = r.destination_yard_id AND d.code = 'NAGAD'
+              WHERE r.deleted_at IS NULL`,
+      }).then(({ rows }) => {
+        if (Number(rows[0].n) > 0) return;
+
+        cy.visit("/dashboard/routes");
+        cy.contains("button", "Add route", { timeout: 20000 }).click();
+        cy.contains("Add Route", { timeout: 15000 }).should("be.visible");
+        cy.get(".mantine-Modal-content").contains("button", "Add milestone").click();
+        const pickYard = (index: number, yard: string) => {
+          cy.get('.mantine-Modal-content input[placeholder="Select yard"]')
+            .eq(index)
+            .click({ force: true });
+          cy.get('[role="option"]:visible').contains(yard).click();
+        };
+        pickYard(0, ORIGIN_YARD);
+        pickYard(1, MID_YARD);
+        pickYard(2, PORT_YARD);
+        cy.get(".mantine-Modal-content").contains("button", "Save").click();
+      });
+    });
+
+    it("operations schedules both segment trains — same route, same day", () => {
+      cy.loginBackoffice(opsStaff);
+      // Two different physical trains may share a route+day (the guard only
+      // blocks the SAME train twice); export windows are per-schedule.
+      dbScheduleFor(TRAIN_W).then(({ rows }) => {
+        if (rows.length === 0) createSchedule(TRAIN_W, DEPART_W);
+      });
+      dbScheduleFor(TRAIN_F).then(({ rows }) => {
+        if (rows.length === 0) createSchedule(TRAIN_F, DEPART_F);
+      });
+
+      // The export window opens at departure − 24h CLAMPED into the booking
+      // desk hours (8–17 EAT), and the engine can take minutes to advance a
+      // second same-day train. Force both windows OPEN directly — the spec
+      // arranges window state, it does not test the window engine.
+      for (const trainCode of [TRAIN_W, TRAIN_F]) {
+        dbScheduleFor(trainCode).then(({ rows }) => {
+          expect(rows, `schedule for ${trainCode}`).to.have.length(1);
+          cy.task("db:query", {
+            sql: `UPDATE freight.train_schedules
+                  SET window_opens_at = LEAST(window_opens_at, now()),
+                      window_phase = 'OPEN',
+                      booking_window_status = 'OPEN'
+                  WHERE id = $1 AND booking_window_status <> 'FULL'`,
+            params: [rows[0].id],
+          });
+        });
+      }
+
+      // Belt-and-braces: confirm the engine keeps them OPEN.
+      const waitForOpen = (trainCode: string, attempt: number) => {
+        dbScheduleFor(trainCode).then(({ rows }) => {
+          expect(rows, `schedule for ${trainCode}`).to.have.length(1);
+          if (rows[0].booking_window_status === "OPEN") return;
+          expect(attempt, `${trainCode} window OPEN`).to.be.lessThan(60);
+          cy.wait(10000).then(() => waitForOpen(trainCode, attempt + 1));
+        });
+      };
+      waitForOpen(TRAIN_W, 0);
+      waitForOpen(TRAIN_F, 0);
+    });
+
+    // ── Tolerance train (TRN-SEG-W) ──────────────────────────────────────────
+
+    it("customer books 130T of wheat Mojo→Djibouti", () => {
+      cy.loginPortal(customer);
+      dbContractId(REF.exportMojo).then((id) =>
+        cy.visitPortal(`/contracts/${id}/bookings/new`),
+      );
+      cy.contains("New Shipment Booking", { timeout: 20000 }).should("be.visible");
+      fill(/^Quantity \(tons\)/, "130");
+      pickShipmentDay(DEPART_W);
+      cy.contains("button", "Review price & book").should("not.be.disabled").click();
+      cy.contains("Confirm shipment price", { timeout: 30000 }).should("be.visible");
+      cy.contains("button", "Confirm & book").click();
+      cy.location("pathname", { timeout: 30000 }).should("match", /^\/bookings\/.+/);
+    });
+
+    it("the wheat lands on the tolerance train and allocates", () => {
+      acceptOperationRequest(REF.exportMojo);
+
+      // FCFS picks the earliest fitting train of the day — the W train.
+      withSchedule(TRAIN_W, (s) => {
+        withBooking(REF.exportMojo, (b) => {
+          expect(b.status).to.eq("SELECTED_FOR_BATCH");
+          expect(b.train_schedule_id, "reserved on the tolerance train").to.eq(s.id);
+        });
+      });
+      markPaidAndAssertAllocated(REF.exportMojo);
+    });
+
+    it("customer books the first intercity pair Mojo→Dire", () => {
+      bookIntercityPair(REF.ic1, 0);
+    });
+
+    it("the ride-along boards the shared leg through the overage tolerance", () => {
+      // Mojo→Dire now carries 179.6T (wheat). Adding 70.4T (2×20ft VGM 24 on
+      // one NW5) puts the leg at 250T — over the 240T base, inside 240+90.
+      // Before the tolerance fix the second loco's NULL tolerance zeroed the
+      // set and this exact allocation failed at "3500" scale.
+      acceptOperationRequest(REF.ic1);
+      acceptRideAlong(TRAIN_W, REF.ic1);
+
+      withSchedule(TRAIN_W, (s) => {
+        withBooking(REF.ic1, (b) => {
+          expect(b.status).to.eq("SELECTED_FOR_BATCH");
+          expect(b.train_schedule_id).to.eq(s.id);
+          expect(new Date(b.payment_deadline!).getTime()).to.be.at.most(
+            new Date(s.window_closes_at).getTime(),
+          );
+        });
+      });
+      markPaidAndAssertAllocated(REF.ic1);
+    });
+
+    it("customer books the second intercity pair Mojo→Dire", () => {
+      bookIntercityPair(REF.ic2, 2);
+    });
+
+    it("a second ride-along still fits whole — tolerance spends per booking, not once", () => {
+      // 250T + 70.4T = 320.4T on Mojo→Dire — still under the 330T ceiling.
+      acceptOperationRequest(REF.ic2);
+      acceptRideAlong(TRAIN_W, REF.ic2);
+      markPaidAndAssertAllocated(REF.ic2);
+
+      // The border edge (Dire→Djibouti) still has room, so the tolerance
+      // train's window must NOT be FULL — fullness is directional.
+      withSchedule(TRAIN_W, (s) => {
+        expect(s.booking_window_status, "W window stays open").to.eq("OPEN");
+      });
+    });
+
+    it("the schedule detail strip shows per-leg gross against the tolerance ceiling", () => {
+      cy.loginBackoffice(opsStaff);
+      withSchedule(TRAIN_W, (s) =>
+        cy.visit(`/dashboard/operations/train-scheduling-v2/${s.id}`),
+      );
+      // Mojo→Dire: 179.6 (wheat) + 70.4 + 70.4 (ride-alongs) = 320.4T gross;
+      // ceiling = 240 base + 90 tolerance = 330T (the weakest CONFIGURED
+      // tolerance governs — the second loco has none set).
+      cy.contains("320.4 / 330 T gross", { timeout: 30000 }).should("exist");
+      // Border leg carries only the wheat.
+      cy.contains("179.6 / 330 T gross").should("exist");
+    });
+
+    // ── Border-full train (TRN-SEG-F) ────────────────────────────────────────
+
+    it("customer books an 8×20ft export from the MID yard", () => {
+      cy.loginPortal(customer);
+      dbContractId(REF.exportDire).then((id) =>
+        cy.visitPortal(`/contracts/${id}/bookings/new`),
+      );
+      cy.contains("New Shipment Booking", { timeout: 20000 }).should("be.visible");
+      fill(/^Quantity/, "8");
+      cy.get('input[placeholder*="MSCU"]', { timeout: 15000 }).should("have.length", 8);
+      for (let i = 0; i < 8; i += 1) {
+        cy.get('input[placeholder*="MSCU"]').eq(i).type(isoNumber("MSCU", 10 + i));
+      }
+      cy.get('input[placeholder*="24.5"]').each(($input) => {
+        cy.wrap($input).clear({ force: true }).type("10", { force: true });
+      });
+      pickShipmentDay(DEPART_F);
+      cy.contains("button", "Review price & book").should("not.be.disabled").click();
+      cy.contains("Confirm shipment price", { timeout: 30000 }).should("be.visible");
+      cy.contains("button", "Confirm & book").click();
+      cy.location("pathname", { timeout: 30000 }).should("match", /^\/bookings\/.+/);
+    });
+
+    it("the export fills the border edge — the window goes FULL for the direction", () => {
+      acceptOperationRequest(REF.exportDire);
+
+      // 8×20ft = 4 wagons. W's border edge has only 2 wagons free (the wheat
+      // holds the other 2), so FCFS lands this Dire→Djibouti sub-corridor
+      // booking on the F train — all 4 of its wagons, but only past Dire.
+      withSchedule(TRAIN_F, (s) => {
+        withBooking(REF.exportDire, (b) => {
+          expect(b.status).to.eq("SELECTED_FOR_BATCH");
+          expect(b.train_schedule_id, "reserved on the border-full train").to.eq(s.id);
+        });
+      });
+      markPaidAndAssertAllocated(REF.exportDire);
+
+      // Every wagon on the border edge is committed: the train is FULL for
+      // its trade direction even though Mojo→Dire runs completely empty.
+      const waitForFull = (attempt: number) => {
+        dbScheduleFor(TRAIN_F).then(({ rows }) => {
+          if (rows[0]?.booking_window_status === "FULL") return;
+          expect(attempt, "F window FULL").to.be.lessThan(20);
+          cy.wait(3000).then(() => waitForFull(attempt + 1));
+        });
+      };
+      waitForFull(0);
+    });
+
+    it("customer books the third intercity pair Mojo→Dire", () => {
+      bookIntercityPair(REF.ic3, 4);
+    });
+
+    it("the FULL train still accepts and allocates an intercity ride-along on its free leg", () => {
+      // Mojo→Dire on the F train is empty (the export boards at Dire): the
+      // ride-along uses the SAME wagons there and alights before they load.
+      // The old whole-train sum — 169.6 + 70.4 = 240T > 200T pull — rejected
+      // this; per-edge math sees 70.4T on Mojo→Dire and 169.6T on the border,
+      // both within the cap. The FULL flag closes the export window only.
+      acceptOperationRequest(REF.ic3);
+      acceptRideAlong(TRAIN_F, REF.ic3);
+
+      withSchedule(TRAIN_F, (s) => {
+        withBooking(REF.ic3, (b) => {
+          expect(b.status).to.eq("SELECTED_FOR_BATCH");
+          expect(b.train_schedule_id, "accepted onto the FULL train").to.eq(s.id);
+        });
+      });
+
+      // Mark paid: PAID + SCHEDULED + linked. Wagon allocation is asserted
+      // only as far as today's model supports: physical wagon pinning is
+      // slot-exclusive (one wagon serves ONE slot), so the same wagon cannot
+      // yet be pinned to the intercity's Mojo→Dire slot AND the export's
+      // Dire→Nagad slot even though the per-edge budget admits both. KNOWN
+      // GAP — when wagon↔slot pinning becomes leg-aware, restore
+      // markPaidAndAssertAllocated(REF.ic3) here.
+      withBooking(REF.ic3, (b) => {
+        cy.apiLogin(opsStaff).then(({ token }) => {
+          cy.request({
+            method: "POST",
+            url: `${apiUrl()}/api/train-scheduling/bookings/${b.id}/mark-paid`,
+            headers: { Authorization: `Bearer ${token}` },
+          })
+            .its("status")
+            .should("be.oneOf", [200, 201]);
+        });
+      });
+      withBooking(REF.ic3, (b) => {
+        expect(b.status).to.eq("PAID");
+        expect(b.scheduling_status).to.eq("SCHEDULED");
+        cy.task<{ rows: Array<{ n: string }> }>("db:query", {
+          sql: `SELECT count(*) AS n FROM freight.train_schedule_bookings
+                WHERE booking_id = $1 AND deleted_at IS NULL`,
+          params: [b.id],
+        }).then(({ rows }) => {
+          expect(Number(rows[0].n), "train_schedule_bookings link").to.eq(1);
+        });
+      });
+
+      // The ride-along never reopens the export window.
+      withSchedule(TRAIN_F, (s) => {
+        expect(s.booking_window_status, "F window stays FULL").to.eq("FULL");
+      });
+    });
+  },
+);
+
+export {};
--- a/e2e/freight/cypress/fixtures/seed-segment-weight.sql
+++ b/e2e/freight/cypress/fixtures/seed-segment-weight.sql
@@ -0,0 +1,175 @@
+-- Arrange-data for flows/segment_weight.cy.ts. Idempotent.
+-- Run AFTER seed-intercity.sql + seed-export.sql (container types, E2E_WHEAT
+-- cargo, Mojo→Djibouti rates, yard distances come from those).
+--
+-- Two dedicated trains on the Mojo → Dire Dawa → Djibouti Port corridor:
+--
+--   TRN-SEG-W ("tolerance train")  — locos 240T pull; LOCO-SEG-A carries a 90T
+--     overage tolerance, LOCO-SEG-B has NONE CONFIGURED (null). The S-2026-00024
+--     regression pair: min-across-locos must keep the 90, not zero it.
+--     Consist: 2 CW4 (bulk) + 2 NW5 (containers).
+--
+--   TRN-SEG-F ("border-full train") — locos 200T pull, no tolerance.
+--     Consist: 4 NW5. An 8×20ft export boarding at Dire Dawa commits every
+--     wagon on the border edge → the train goes FULL for its trade direction
+--     while the Mojo→Dire leg stays free: an intercity ride-along boards the
+--     SAME wagons there and alights before the export loads them.
+--
+-- Wagons are dedicated inserts (WGN-SEG-*) so the fixture never competes with
+-- other specs for free fleet stock, and the corridor targets NAGAD (not
+-- DJIB_PORT) so no other spec's same-day schedule can steal FCFS bookings.
+
+-- 0. Reset any PREVIOUS segment-weight run (namespaced: TRN-SEG-* trains,
+-- CTR-SEG-* contracts, WGN-SEG-* wagons) so the spec re-runs on a warm DB.
+-- Everything is age-guarded (45 min): Cypress re-runs the spec's before()
+-- hook on cross-origin reloads, and an unguarded reset would soft-delete the
+-- CURRENT run's own schedules and contracts mid-flight. Consequence: rerun
+-- the spec no sooner than 45 minutes after a crashed run (or restack).
+UPDATE freight.train_schedules ts
+SET deleted_at = now(), booking_window_status = 'CLOSED'
+WHERE ts.deleted_at IS NULL
+  AND ts.created_at < now() - interval '45 minutes'
+  AND ts.train_set_id IN (
+    SELECT se.id FROM freight.train_sets se
+    JOIN freight.trains t ON t.id = se.train_id
+    WHERE t.code LIKE 'TRN-SEG-%'
+  );
+
+UPDATE freight.wagon_booking_allocations a
+SET deleted_at = now()
+WHERE a.deleted_at IS NULL
+  AND a.booking_id IN (
+    SELECT b.id FROM freight.bookings b
+    JOIN freight.contracts c ON c.id = b.contract_id
+    WHERE c.reference LIKE 'CTR-SEG-%'
+      AND c.created_at < now() - interval '45 minutes'
+  );
+
+UPDATE freight.bookings b
+SET deleted_at = now()
+WHERE b.deleted_at IS NULL
+  AND b.contract_id IN (
+    SELECT id FROM freight.contracts
+    WHERE reference LIKE 'CTR-SEG-%'
+      AND created_at < now() - interval '45 minutes'
+  );
+
+UPDATE freight.contracts
+SET deleted_at = now()
+WHERE deleted_at IS NULL
+  AND reference LIKE 'CTR-SEG-%'
+  AND created_at < now() - interval '45 minutes';
+
+-- Un-pin only wagons whose pin points at a dead schedule — live pins from the
+-- current run must survive a mid-run re-seed.
+UPDATE freight.wagons w
+SET current_train_schedule_id = NULL,
+    train_set_wagon_id = NULL,
+    current_yard_id = (SELECT id FROM freight.yards WHERE code = 'MOJO')
+WHERE w.wagon_number LIKE 'WGN-SEG-%'
+  AND w.current_train_schedule_id IS NOT NULL
+  AND w.current_train_schedule_id IN (
+    SELECT id FROM freight.train_schedules WHERE deleted_at IS NOT NULL
+  );
+
+-- 1. Locomotives at Mojo.
+INSERT INTO freight.locomotives
+  (id, code, max_pull_weight_tons, max_train_length_meters,
+   overage_tolerance_tons, current_yard_id)
+SELECT gen_random_uuid(), v.code, v.pull, 760, v.tol, y.id
+FROM (VALUES
+        ('LOCO-SEG-A', 240, 90),
+        ('LOCO-SEG-B', 240, NULL),
+        ('LOCO-SEG-C', 200, NULL),
+        ('LOCO-SEG-D', 200, NULL)
+     ) AS v(code, pull, tol)
+JOIN freight.yards y ON y.code = 'MOJO'
+WHERE NOT EXISTS (SELECT 1 FROM freight.locomotives l WHERE l.code = v.code);
+
+-- 2. Built trains at Mojo.
+INSERT INTO freight.trains (id, code, train_name, capacity_tons, current_yard_id)
+SELECT gen_random_uuid(), v.code, v.name, 2000, y.id
+FROM (VALUES
+        ('TRN-SEG-W', 'E2E Tolerance Carrier'),
+        ('TRN-SEG-F', 'E2E Border-Full Carrier')
+     ) AS v(code, name)
+JOIN freight.yards y ON y.code = 'MOJO'
+WHERE NOT EXISTS (SELECT 1 FROM freight.trains t WHERE t.code = v.code);
+
+-- 3. Couple the locomotive pairs (schedulable trains need >= 2 locos).
+INSERT INTO freight.train_locomotives (id, train_id, locomotive_id, sequence_no)
+SELECT gen_random_uuid(), t.id, l.id, v.seq
+FROM (VALUES
+        ('TRN-SEG-W', 'LOCO-SEG-A', 0),
+        ('TRN-SEG-W', 'LOCO-SEG-B', 1),
+        ('TRN-SEG-F', 'LOCO-SEG-C', 0),
+        ('TRN-SEG-F', 'LOCO-SEG-D', 1)
+     ) AS v(train_code, loco_code, seq)
+JOIN freight.trains t ON t.code = v.train_code
+JOIN freight.locomotives l ON l.code = v.loco_code
+WHERE NOT EXISTS (
+  SELECT 1 FROM freight.train_locomotives tl
+  WHERE tl.train_id = t.id AND tl.locomotive_id = l.id
+);
+
+-- 4. Dedicated wagons, parked at Mojo.
+INSERT INTO freight.wagons (id, wagon_number, wagon_type_id, current_yard_id)
+SELECT gen_random_uuid(), v.num, wt.id, y.id
+FROM (VALUES
+        ('WGN-SEG-C1', 'CW4'), ('WGN-SEG-C2', 'CW4'),
+        ('WGN-SEG-N1', 'NW5'), ('WGN-SEG-N2', 'NW5'),
+        ('WGN-SEG-N3', 'NW5'), ('WGN-SEG-N4', 'NW5'),
+        ('WGN-SEG-N5', 'NW5'), ('WGN-SEG-N6', 'NW5')
+     ) AS v(num, wt_code)
+JOIN freight.wagon_types wt ON wt.code = v.wt_code
+JOIN freight.yards y ON y.code = 'MOJO'
+WHERE NOT EXISTS (SELECT 1 FROM freight.wagons w WHERE w.wagon_number = v.num);
+
+-- 5. Couple them: W = 2 CW4 + 2 NW5, F = 4 NW5.
+UPDATE freight.wagons w
+SET train_id = t.id, sequence_number = v.seq
+FROM freight.trains t,
+     (VALUES
+        ('WGN-SEG-C1', 'TRN-SEG-W', 1), ('WGN-SEG-C2', 'TRN-SEG-W', 2),
+        ('WGN-SEG-N1', 'TRN-SEG-W', 3), ('WGN-SEG-N2', 'TRN-SEG-W', 4),
+        ('WGN-SEG-N3', 'TRN-SEG-F', 1), ('WGN-SEG-N4', 'TRN-SEG-F', 2),
+        ('WGN-SEG-N5', 'TRN-SEG-F', 3), ('WGN-SEG-N6', 'TRN-SEG-F', 4)
+     ) AS v(num, train_code, seq)
+WHERE w.wagon_number = v.num
+  AND t.code = v.train_code
+  AND w.train_id IS DISTINCT FROM t.id;
+
+-- 6. LIVE export rates for the NAGAD corridor: bulk from Mojo (tolerance
+-- train's wheat) and container from Dire Dawa (border-full scenario's
+-- mid-route export).
+INSERT INTO freight.rates
+  (id, rate_type, applies_to, trigger, currency, rate_value, rate_unit, status,
+   origin_yard_id, destination_yard_id, proposed_by_staff_id)
+SELECT gen_random_uuid(), v.rate_type, v.applies_to, 'ALWAYS', 'USD', v.value,
+       v.unit, 'LIVE', a.id, b.id, u.id
+FROM (VALUES
+        ('BULK_EXPORT', 'BULK', 'MOJO', 25, 'PER_TON'),
+        ('CONTAINER_EXPORT', 'CONTAINER', 'DIRE_DAWA', 600, 'PER_CONTAINER')
+     ) AS v(rate_type, applies_to, origin_code, value, unit)
+JOIN freight.yards a ON a.code = v.origin_code
+JOIN freight.yards b ON b.code = 'NAGAD'
+JOIN iam.users u ON u.email = 'operation@edr.local'
+WHERE NOT EXISTS (
+  SELECT 1 FROM freight.rates r
+  WHERE r.rate_type = v.rate_type
+    AND r.origin_yard_id = a.id AND r.destination_yard_id = b.id
+    AND r.deleted_at IS NULL
+);
+
+-- 7. Segment distance for the new corridor's border leg (Mojo–Dire comes
+-- from seed-intercity.sql).
+INSERT INTO freight.yard_distances (id, from_yard_id, to_yard_id, distance_km)
+SELECT gen_random_uuid(), a.id, b.id, 460
+FROM freight.yards a
+JOIN freight.yards b ON b.code = 'NAGAD'
+WHERE a.code = 'DIRE_DAWA'
+  AND NOT EXISTS (
+    SELECT 1 FROM freight.yard_distances d
+    WHERE (d.from_yard_id = a.id AND d.to_yard_id = b.id)
+       OR (d.from_yard_id = b.id AND d.to_yard_id = a.id)
+  );
--- a/packages/types/src/freight/contracts.ts
+++ b/packages/types/src/freight/contracts.ts
@@ -848,6 +848,8 @@ export interface CreateBookingUnderContractDto {
  equipmentReturn?: string;
  containers?: CreateBookingContainerLineDto[];
  bulkLines?: CreateBulkLineDto[];
+  /** What the containers carry — captured per booking (container freight). */
+  cargoFreeText?: string;
  notes?: string;
 }