diff --git a/apps/edr-freight-api/package.json b/apps/edr-freight-api/package.json
index 0c6b1c727..79e350cc7 100644
--- a/apps/edr-freight-api/package.json
+++ b/apps/edr-freight-api/package.json
@@ -18,6 +18,7 @@
     "type-check": "tsc --noEmit",
     "seed:demo-scheduling": "ts-node -r tsconfig-paths/register src/scripts/seed-demo-scheduling.ts",
     "seed:freight-demo": "ts-node -r tsconfig-paths/register src/scripts/seed-freight-demo.ts",
+    "seed:warehouse-layout": "ts-node -r tsconfig-paths/register src/scripts/seed-warehouse-layout.ts",
     "seed:warehouse-demo": "ts-node -r tsconfig-paths/register src/scripts/seed-warehouse-demo.ts",
     "seed:warehouse-export-receive-ready": "ts-node -r tsconfig-paths/register src/scripts/seed-warehouse-export-receive-ready.ts",
     "seed:export-djibouti-interchange-demo": "ts-node -r tsconfig-paths/register src/scripts/seed-export-djibouti-interchange-demo.ts",
diff --git a/apps/edr-freight-api/src/migrations/3780000000000-ScheduleCancellationReason.ts b/apps/edr-freight-api/src/migrations/3780000000000-ScheduleCancellationReason.ts
new file mode 100644
index 000000000..dbb68fe61
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3780000000000-ScheduleCancellationReason.ts
@@ -0,0 +1,28 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Why a train schedule was cancelled, captured at cancel time. Staff pick a
+ * reason in the cancel dialog and every view of the cancelled schedule reads it
+ * back — a cancelled train on the board used to say nothing about why it died.
+ */
+export class ScheduleCancellationReason3780000000000 implements MigrationInterface {
+  name = 'ScheduleCancellationReason3780000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "freight"."train_schedules"
+        ADD COLUMN IF NOT EXISTS "cancellation_reason" varchar(500),
+        ADD COLUMN IF NOT EXISTS "cancelled_at" timestamptz,
+        ADD COLUMN IF NOT EXISTS "cancelled_by_user_id" uuid
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE "freight"."train_schedules"
+        DROP COLUMN IF EXISTS "cancellation_reason",
+        DROP COLUMN IF EXISTS "cancelled_at",
+        DROP COLUMN IF EXISTS "cancelled_by_user_id"
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3790000000000-EmptyContainerReturnCompanyName.ts b/apps/edr-freight-api/src/migrations/3790000000000-EmptyContainerReturnCompanyName.ts
new file mode 100644
index 000000000..b0088da66
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3790000000000-EmptyContainerReturnCompanyName.ts
@@ -0,0 +1,24 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Empties backfilled into the yard belong to a company that may not be a
+ * registered customer yet, so `customer_id` cannot hold it. `company_name` is
+ * the typed fallback, and the display label when the customer IS registered.
+ */
+export class EmptyContainerReturnCompanyName3790000000000 implements MigrationInterface {
+  name = 'EmptyContainerReturnCompanyName3790000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.empty_container_returns
+        ADD COLUMN IF NOT EXISTS company_name varchar(200)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.empty_container_returns
+        DROP COLUMN IF EXISTS company_name
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3800000000000-WarehouseInventoryBacklogRegistration.ts b/apps/edr-freight-api/src/migrations/3800000000000-WarehouseInventoryBacklogRegistration.ts
new file mode 100644
index 000000000..ba4ba7cdb
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3800000000000-WarehouseInventoryBacklogRegistration.ts
@@ -0,0 +1,34 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Backlog registration of full containers that were already sitting in a yard
+ * before the system knew about them. Such a row carries a true, backdated
+ * `arrived_at` for the record but accrues NO storage or demurrage — the
+ * operator decided these are not billable retroactively — so the flag exists
+ * to keep the fee engine off them.
+ *
+ * `company_id` / `company_name` carry the owner, since a backlog row has no
+ * booking to inherit one from. The name is free text for a company that is not
+ * a registered customer yet.
+ */
+export class WarehouseInventoryBacklogRegistration3800000000000 implements MigrationInterface {
+  name = 'WarehouseInventoryBacklogRegistration3800000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.warehouse_inventory
+        ADD COLUMN IF NOT EXISTS backlog_registration boolean NOT NULL DEFAULT false,
+        ADD COLUMN IF NOT EXISTS company_id uuid,
+        ADD COLUMN IF NOT EXISTS company_name varchar(200)
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.warehouse_inventory
+        DROP COLUMN IF EXISTS backlog_registration,
+        DROP COLUMN IF EXISTS company_id,
+        DROP COLUMN IF EXISTS company_name
+    `);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3810000000000-WarehouseZoneDeletePermission.ts b/apps/edr-freight-api/src/migrations/3810000000000-WarehouseZoneDeletePermission.ts
new file mode 100644
index 000000000..fa2bcf7ec
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3810000000000-WarehouseZoneDeletePermission.ts
@@ -0,0 +1,55 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Seed `edr_freight_app:warehouse_zones:delete` — the zone counterpart of the
+ * warehouse and yard delete permissions, which already exist.
+ *
+ * `ROLE_PERMISSION_PRESETS` spreads `Object.values(FREIGHT_PERMS.warehouseZones)`
+ * into the warehouse positions, so the moment the key is added to the registry
+ * `FreightPositionsSeeder.loadPermissionIds` resolves it against `iam.permissions`
+ * at boot — and throws `missing_permissions:<key>` if the row is absent. The
+ * catalog is otherwise written by `EdrOrgSeeder`, which skips itself unless
+ * `SEED_EDR_ORG` is set, so a migration is the only path that runs everywhere.
+ *
+ * Idempotent on `key`; keeps the registry's fixed uuid so every environment
+ * lands on the same id. Skips silently when the freight application row is
+ * absent, since there is nothing to attach to.
+ */
+export class WarehouseZoneDeletePermission3810000000000 implements MigrationInterface {
+  private static readonly KEY = 'edr_freight_app:warehouse_zones:delete';
+  private static readonly ID = 'f1c00001-0001-4000-8000-000000000004';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `INSERT INTO iam.permissions (id, key, name, application_id)
+       SELECT $2::uuid,
+              $1::varchar,
+              '{"am": "Delete warehouse zone", "en": "Delete warehouse zone"}'::jsonb,
+              a.id
+         FROM iam.application a
+        WHERE a.key = 'edr_freight_app'
+          AND NOT EXISTS (SELECT 1 FROM iam.permissions p WHERE p.key = $1::varchar)`,
+      [WarehouseZoneDeletePermission3810000000000.KEY, WarehouseZoneDeletePermission3810000000000.ID],
+    );
+  }
+
+  /**
+   * Grants go first, or the delete trips the position/role permission foreign
+   * keys — a half-removed permission is worse than one left in place.
+   */
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DELETE FROM iam.position_permissions
+        WHERE permission_id IN (SELECT id FROM iam.permissions WHERE key = $1)`,
+      [WarehouseZoneDeletePermission3810000000000.KEY],
+    );
+    await queryRunner.query(
+      `DELETE FROM iam.role_permissions
+        WHERE permission_id IN (SELECT id FROM iam.permissions WHERE key = $1)`,
+      [WarehouseZoneDeletePermission3810000000000.KEY],
+    );
+    await queryRunner.query(`DELETE FROM iam.permissions WHERE key = $1`, [
+      WarehouseZoneDeletePermission3810000000000.KEY,
+    ]);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3820000000000-WarehouseFreightType.ts b/apps/edr-freight-api/src/migrations/3820000000000-WarehouseFreightType.ts
new file mode 100644
index 000000000..563128411
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3820000000000-WarehouseFreightType.ts
@@ -0,0 +1,21 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * `freight.warehouses.freight_type` — CONTAINER or BULK, or null for a site
+ * that takes both.
+ *
+ * Nullable with no backfill on purpose: every existing warehouse predates the
+ * field and is unrestricted today, so writing a value would narrow live
+ * allocation behind the operator's back.
+ */
+export class WarehouseFreightType3820000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.warehouses ADD COLUMN IF NOT EXISTS freight_type varchar(16)`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE freight.warehouses DROP COLUMN IF EXISTS freight_type`);
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3830000000000-WarehouseZoneStacksSlots.ts b/apps/edr-freight-api/src/migrations/3830000000000-WarehouseZoneStacksSlots.ts
new file mode 100644
index 000000000..38341a1f1
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3830000000000-WarehouseZoneStacksSlots.ts
@@ -0,0 +1,128 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Physical container positions below the zone: a stack is the ground footprint,
+ * a slot is one level in it. Adds `stack_id` / `slot_id` to warehouse inventory.
+ *
+ * Everything is additive and nullable. Existing inventory keeps warehouse /
+ * yard / zone as its only location and stays valid — nothing is backfilled,
+ * because no one can know where a box already in the yard is actually stacked.
+ *
+ * Occupancy is not stored on the slot. `uq_warehouse_inventory_active_slot`
+ * makes the inventory row the single source of truth: one live placement per
+ * slot, enforced by Postgres. Its status list must stay in step with
+ * `SLOT_OCCUPYING_STATUSES` in warehouse-inventory.entity.ts.
+ */
+export class WarehouseZoneStacksSlots3830000000000 implements MigrationInterface {
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouse_zone_stacks (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        zone_id uuid NOT NULL REFERENCES freight.warehouse_zones(id) ON DELETE CASCADE,
+        code varchar(40) NOT NULL,
+        name varchar(160),
+        "row" varchar(20),
+        bay varchar(20),
+        "position" varchar(20),
+        max_stack_height int NOT NULL DEFAULT 3,
+        status varchar(16) NOT NULL DEFAULT 'ACTIVE',
+        is_active boolean NOT NULL DEFAULT true,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        CONSTRAINT chk_warehouse_zone_stacks_height CHECK (max_stack_height >= 1)
+      )
+    `);
+
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_warehouse_zone_stacks_zone ON freight.warehouse_zone_stacks (zone_id)`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_warehouse_zone_stacks_status ON freight.warehouse_zone_stacks (status)`,
+    );
+    // Partial: a soft-deleted stack must not block reusing its code.
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX IF NOT EXISTS uq_warehouse_zone_stacks_zone_code
+         ON freight.warehouse_zone_stacks (zone_id, code) WHERE deleted_at IS NULL`,
+    );
+
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.warehouse_zone_slots (
+        id uuid PRIMARY KEY DEFAULT gen_random_uuid(),
+        stack_id uuid NOT NULL REFERENCES freight.warehouse_zone_stacks(id) ON DELETE CASCADE,
+        level int NOT NULL,
+        status varchar(16) NOT NULL DEFAULT 'AVAILABLE',
+        is_active boolean NOT NULL DEFAULT true,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        CONSTRAINT chk_warehouse_zone_slots_level CHECK (level >= 1)
+      )
+    `);
+
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_warehouse_zone_slots_stack ON freight.warehouse_zone_slots (stack_id, level)`,
+    );
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX IF NOT EXISTS uq_warehouse_zone_slots_stack_level
+         ON freight.warehouse_zone_slots (stack_id, level) WHERE deleted_at IS NULL`,
+    );
+
+    await queryRunner.query(
+      `ALTER TABLE freight.warehouse_inventory ADD COLUMN IF NOT EXISTS stack_id uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE freight.warehouse_inventory ADD COLUMN IF NOT EXISTS slot_id uuid`,
+    );
+
+    // Named FKs added defensively — ADD CONSTRAINT has no IF NOT EXISTS.
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE freight.warehouse_inventory
+          ADD CONSTRAINT fk_warehouse_inventory_stack
+          FOREIGN KEY (stack_id) REFERENCES freight.warehouse_zone_stacks(id);
+      EXCEPTION WHEN duplicate_object THEN NULL; END $$
+    `);
+    await queryRunner.query(`
+      DO $$ BEGIN
+        ALTER TABLE freight.warehouse_inventory
+          ADD CONSTRAINT fk_warehouse_inventory_slot
+          FOREIGN KEY (slot_id) REFERENCES freight.warehouse_zone_slots(id);
+      EXCEPTION WHEN duplicate_object THEN NULL; END $$
+    `);
+
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_warehouse_inventory_stack ON freight.warehouse_inventory (stack_id)`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX IF NOT EXISTS idx_warehouse_inventory_slot ON freight.warehouse_inventory (slot_id)`,
+    );
+
+    // One live container per slot. Statuses past the yard gate (LOADED,
+    // DISPATCHED, DELIVERED, UNLOADED_AT_DJIBOUTI_PORT) free the position
+    // without any exit path having to clear the column.
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS uq_warehouse_inventory_active_slot
+        ON freight.warehouse_inventory (slot_id)
+        WHERE deleted_at IS NULL
+          AND slot_id IS NOT NULL
+          AND status IN ('UNLOADED','RECEIVED','STORED','RESERVED','READY_FOR_LOADING','READY_FOR_PICKUP')
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.uq_warehouse_inventory_active_slot`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_warehouse_inventory_slot`);
+    await queryRunner.query(`DROP INDEX IF EXISTS freight.idx_warehouse_inventory_stack`);
+    await queryRunner.query(
+      `ALTER TABLE freight.warehouse_inventory DROP CONSTRAINT IF EXISTS fk_warehouse_inventory_slot`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE freight.warehouse_inventory DROP CONSTRAINT IF EXISTS fk_warehouse_inventory_stack`,
+    );
+    await queryRunner.query(`ALTER TABLE freight.warehouse_inventory DROP COLUMN IF EXISTS slot_id`);
+    await queryRunner.query(`ALTER TABLE freight.warehouse_inventory DROP COLUMN IF EXISTS stack_id`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouse_zone_slots`);
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.warehouse_zone_stacks`);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/billing/billing.service.ts b/apps/edr-freight-api/src/modules/billing/billing.service.ts
index cf41998ba..1dd4c5656 100644
--- a/apps/edr-freight-api/src/modules/billing/billing.service.ts
+++ b/apps/edr-freight-api/src/modules/billing/billing.service.ts
@@ -116,6 +116,8 @@ export interface InvoiceListFilters {
   status?: Freight.InvoiceStatus;
   statuses?: Freight.InvoiceStatus[];
   sources?: string[];
+  /** What the invoice bills for (`PREPAID`, `DEMURRAGE`, …) — free-form per source. */
+  types?: string[];
   eimsStatuses?: string[];
   /** Settled payment method, normalised UPPER_SNAKE — see `invoicePaymentMethodExpr`. */
   paymentMethods?: string[];
@@ -306,6 +308,9 @@ export class BillingService {
         sources: filter.sources,
       });
     }
+    if (filter.types?.length) {
+      qb.andWhere("invoice.type IN (:...types)", { types: filter.types });
+    }
     if (filter.eimsStatuses?.length) {
       qb.andWhere("invoice.eimsStatus IN (:...eimsStatuses)", {
         eimsStatuses: filter.eimsStatuses,
diff --git a/apps/edr-freight-api/src/modules/billing/dto/filter-invoice.dto.spec.ts b/apps/edr-freight-api/src/modules/billing/dto/filter-invoice.dto.spec.ts
index 55e6b19d2..45c7acb51 100644
--- a/apps/edr-freight-api/src/modules/billing/dto/filter-invoice.dto.spec.ts
+++ b/apps/edr-freight-api/src/modules/billing/dto/filter-invoice.dto.spec.ts
@@ -22,6 +22,7 @@ describe("FilterInvoiceDto", () => {
       search: "INV-2026",
       statuses: "PENDING,OVERDUE",
       sources: "booking,warehouse",
+      types: "PREPAID,WAGON_CANCEL_FEE",
       eimsStatuses: "NOT_SUBMITTED",
       currency: "etb",
       issuedFrom: "2026-08-01T00:00:00.000Z",
@@ -39,6 +40,7 @@ describe("FilterInvoiceDto", () => {
     expect(errors).toEqual([]);
     expect(dto.statuses).toEqual(["PENDING", "OVERDUE"]);
     expect(dto.sources).toEqual(["booking", "warehouse"]);
+    expect(dto.types).toEqual(["PREPAID", "WAGON_CANCEL_FEE"]);
     expect(dto.currency).toBe("ETB");
     expect(dto.minAmount).toBe(100);
     expect(dto.hasBalance).toBe(true);
diff --git a/apps/edr-freight-api/src/modules/billing/dto/filter-invoice.dto.ts b/apps/edr-freight-api/src/modules/billing/dto/filter-invoice.dto.ts
index a98ad06c1..fa00fb521 100644
--- a/apps/edr-freight-api/src/modules/billing/dto/filter-invoice.dto.ts
+++ b/apps/edr-freight-api/src/modules/billing/dto/filter-invoice.dto.ts
@@ -89,6 +89,18 @@ export class FilterInvoiceDto {
   @IsIn(Object.values(Freight.InvoiceSource), { each: true })
   sources?: Freight.InvoiceSource[];
 
+  /**
+   * What the invoice bills for (`?types=PREPAID,WAGON_CANCEL_FEE`). Free-form
+   * like `paymentMethods`: every billing source mints its own `type` string, so
+   * an `IsIn` here would silently drop a real value.
+   */
+  @ApiPropertyOptional({ isArray: true, example: ["PREPAID"] })
+  @IsOptional()
+  @Transform(csv)
+  @IsArray()
+  @IsString({ each: true })
+  types?: string[];
+
   /** MoR filing state — Finance's "what still needs registering" cut. */
   @ApiPropertyOptional({ isArray: true, enum: EimsInvoiceStatus })
   @IsOptional()
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-content.sql.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-content.sql.spec.ts
new file mode 100644
index 000000000..0668b9eba
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/booking-content.sql.spec.ts
@@ -0,0 +1,146 @@
+import {
+  CARGO_TYPE_SUBTREE_SQL,
+  bookingContainerCountSql,
+  bookingContainerVgmSql,
+  bookingContentMatchSql,
+  bookingContentSql,
+  bookingHasContainerTypeSql,
+  bookingRequestedCargoSql,
+  bookingRequestedContainerCountSql,
+} from './booking-content.sql';
+
+describe('bookingContentSql', () => {
+  const sql = bookingContentSql('b');
+
+  it('prefers the container lines, since container bookings carry no description', () => {
+    expect(sql.indexOf('freight.booking_container')).toBeLessThan(
+      sql.indexOf('freight.cargo_types'),
+    );
+    expect(sql).toContain('freight.container_types');
+    expect(sql).toContain('bc.deleted_at IS NULL');
+  });
+
+  it('falls back to commodity, then to the free-text description', () => {
+    expect(sql.indexOf('cgt.cargo_type_name')).toBeLessThan(
+      sql.indexOf('b.cargo_free_text'),
+    );
+  });
+
+  // An empty string is not a missing value to COALESCE — without NULLIF a blank
+  // description would win over the commodity behind it.
+  it('treats an empty string as absent at every level', () => {
+    expect(sql.match(/NULLIF/g)).toHaveLength(3);
+  });
+
+  it('rewrites every reference when embedded under another alias', () => {
+    expect(bookingContentSql('bk')).not.toMatch(/\bb\.(cargo|id)/);
+  });
+});
+
+describe('CARGO_TYPE_SUBTREE_SQL', () => {
+  // The filter offers groups, not just leaves, so picking "Bulk" has to reach
+  // commodities at any depth beneath it — two levels today, more tomorrow.
+  it('walks the tree recursively rather than one level of children', () => {
+    expect(CARGO_TYPE_SUBTREE_SQL).toContain('WITH RECURSIVE');
+    expect(CARGO_TYPE_SUBTREE_SQL).toContain('c.parent_group_id = sub.id');
+  });
+
+  it('includes the picked node itself, so a leaf still matches exactly', () => {
+    expect(CARGO_TYPE_SUBTREE_SQL).toContain('WHERE id = :cargoTypeId');
+  });
+});
+
+describe('bookingContentMatchSql', () => {
+  const sql = bookingContentMatchSql('b');
+
+  it('searches all three places content can live', () => {
+    expect(sql).toContain('b.cargo_free_text ILIKE :cargoText');
+    expect(sql).toContain('cgt.cargo_type_name ILIKE :cargoText');
+    expect(sql).toContain('cnt.code ILIKE :cargoText');
+  });
+
+  // Anything but OR would make the text box match nothing for whole freight
+  // types — a container booking has no commodity, a bulk one has no container.
+  it('ORs them, and stays one parenthesised term for andWhere', () => {
+    expect(sql).not.toContain(' AND :cargoText');
+    expect(sql.startsWith('(')).toBe(true);
+    expect(sql.trimEnd().endsWith(')')).toBe(true);
+  });
+});
+
+describe('bookingContainerCountSql', () => {
+  // booking_container is one row per LINE carrying a quantity, so counting rows
+  // would report a 54-container booking as 1.
+  it('sums the line quantities rather than counting lines', () => {
+    expect(bookingContainerCountSql('b')).toContain('SUM(bc.quantity)');
+    expect(bookingContainerCountSql('b')).not.toContain('COUNT(');
+  });
+
+  it('counts every type by default and one type when scoped', () => {
+    expect(bookingContainerCountSql('b')).not.toContain('container_type_id');
+    expect(bookingContainerCountSql('b', true)).toContain(
+      'bc.container_type_id = :containerTypeId',
+    );
+  });
+
+  it('is 0, never NULL, so a bound comparison still decides', () => {
+    expect(bookingContainerCountSql('b')).toContain('COALESCE(SUM(bc.quantity), 0)');
+  });
+
+  it('ignores soft-deleted lines', () => {
+    expect(bookingContainerCountSql('b')).toContain('bc.deleted_at IS NULL');
+    expect(bookingHasContainerTypeSql('b')).toContain('bc.deleted_at IS NULL');
+  });
+
+  it('rewrites the booking reference under another alias', () => {
+    expect(bookingContainerCountSql('bk')).toContain('bc.booking_id = bk.id');
+    expect(bookingHasContainerTypeSql('bk')).toContain('bc.booking_id = bk.id');
+  });
+});
+
+describe('bookingContainerVgmSql', () => {
+  // The whole point: b.cargo_total_weight_vgm is 0 for portal container
+  // bookings, so the weight has to come off the lines.
+  it('reads the lines, never the booking-level column', () => {
+    const sql = bookingContainerVgmSql('b');
+    expect(sql).toContain('SUM(bc.total_vgm_tons)');
+    expect(sql).not.toContain('cargo_total_weight_vgm');
+    expect(sql).toContain('bc.deleted_at IS NULL');
+  });
+});
+
+describe('requested (shipment-request) cargo', () => {
+  const cargo = bookingRequestedCargoSql('b');
+  const count = bookingRequestedContainerCountSql('b');
+
+  it('reads the request, never the booking or its container lines', () => {
+    for (const sql of [cargo, count]) {
+      expect(sql).toContain('freight.booking_requests br');
+      expect(sql).toContain('br.created_booking_id = b.id');
+      expect(sql).not.toContain('freight.booking_container');
+    }
+  });
+
+  // requested_lines is a free-form jsonb column; jsonb_array_elements throws on
+  // a non-array, which would 500 the whole list for one malformed row.
+  it('survives a requested_lines with no container array', () => {
+    for (const sql of [cargo, count]) {
+      expect(sql).toContain("jsonb_typeof(br.requested_lines->'containers') = 'array'");
+      expect(sql).toContain("ELSE '[]'::jsonb");
+    }
+  });
+
+  it('renders the bulk shape too, not only containers', () => {
+    expect(cargo).toContain("'bulk'->>'cargoWeightTons'");
+    expect(cargo).toContain("'bulk'->>'itemCount'");
+  });
+
+  it('counts 0 rather than NULL when no request exists', () => {
+    expect(count).toContain("COALESCE(SUM((l->>'quantity')::int), 0)");
+  });
+
+  it('ignores soft-deleted requests', () => {
+    expect(cargo).toContain('br.deleted_at IS NULL');
+    expect(count).toContain('br.deleted_at IS NULL');
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-content.sql.ts b/apps/edr-freight-api/src/modules/bookings/booking-content.sql.ts
new file mode 100644
index 000000000..744a6bbd8
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/booking-content.sql.ts
@@ -0,0 +1,148 @@
+/**
+ * What the customer said is IN the booking, per freight type — the list
+ * filter, the summary and the export all read this one expression so the
+ * column, the pill and the sheet can never disagree.
+ *
+ * BULK      the commodity picked from the cargo tree (`cargo_types`), falling
+ *           back to the free-text description for a bare group or a legacy row
+ *           that has no commodity.
+ * CONTAINER the wizard asks for no description at all — VGM and contents are
+ *           captured later in operations — so the closest thing to the
+ *           customer's own words is the container lines they entered:
+ *           "2 × 40FT, 1 × 20FT".
+ *
+ * Containers are checked FIRST: a container booking has no `cargo_type_id`
+ * (the API rejects one), so the order only matters for a mixed legacy row,
+ * where the physical lines are the better answer.
+ */
+export function bookingContentSql(alias = 'b'): string {
+  return `COALESCE(
+    NULLIF((SELECT string_agg(bc.quantity || ' × ' || COALESCE(cnt.label, cnt.code), ', '
+                              ORDER BY cnt.size_ft DESC NULLS LAST, cnt.code)
+              FROM freight.booking_container bc
+              JOIN freight.container_types cnt ON cnt.id = bc.container_type_id
+             WHERE bc.booking_id = ${alias}.id AND bc.deleted_at IS NULL), ''),
+    NULLIF((SELECT cgt.cargo_type_name FROM freight.cargo_types cgt
+             WHERE cgt.id = ${alias}.cargo_type_id), ''),
+    NULLIF(${alias}.cargo_free_text, ''))`;
+}
+
+/**
+ * Cargo types at or under `:cargoTypeId`, so picking a GROUP in the filter
+ * matches every commodity beneath it — the same group→commodity drill-down the
+ * booking wizard offers, read back. Recursive because `cargo_types` is an
+ * arbitrary-depth tree (Bulk → Steel Billet → S1 → …), not two levels.
+ */
+export const CARGO_TYPE_SUBTREE_SQL = `(
+  WITH RECURSIVE sub AS (
+    SELECT id FROM freight.cargo_types WHERE id = :cargoTypeId
+    UNION ALL
+    SELECT c.id FROM freight.cargo_types c JOIN sub ON c.parent_group_id = sub.id
+  )
+  SELECT id FROM sub)`;
+
+/**
+ * Contains-match over every part of the content a customer can type or pick:
+ * their own description, the commodity's name, and the container types on the
+ * booking. Bind `:cargoText` already wrapped in `%`.
+ */
+export function bookingContentMatchSql(alias = 'b'): string {
+  return `(${alias}.cargo_free_text ILIKE :cargoText
+    OR EXISTS (SELECT 1 FROM freight.cargo_types cgt
+                WHERE cgt.id = ${alias}.cargo_type_id
+                  AND cgt.cargo_type_name ILIKE :cargoText)
+    OR EXISTS (SELECT 1 FROM freight.booking_container bc
+                 JOIN freight.container_types cnt ON cnt.id = bc.container_type_id
+                WHERE bc.booking_id = ${alias}.id AND bc.deleted_at IS NULL
+                  AND (cnt.label ILIKE :cargoText OR cnt.code ILIKE :cargoText)))`;
+}
+
+/**
+ * Containers on a booking, as a count of physical boxes — `booking_container`
+ * is one row PER LINE with a `quantity`, not one row per box, so this sums the
+ * quantity rather than counting rows.
+ *
+ * `scopedToType` narrows the sum to `:containerTypeId`, which is what makes one
+ * number filter answer both "10 containers in total" and "10 forty-footers":
+ * the count filter reads the container-type filter when one is set, and counts
+ * every type when it is not.
+ */
+export function bookingContainerCountSql(alias = 'b', scopedToType = false): string {
+  return `(SELECT COALESCE(SUM(bc.quantity), 0)
+             FROM freight.booking_container bc
+            WHERE bc.booking_id = ${alias}.id
+              AND bc.deleted_at IS NULL${
+                scopedToType ? '\n              AND bc.container_type_id = :containerTypeId' : ''
+              })`;
+}
+
+/** Bookings carrying at least one line of `:containerTypeId`. */
+export function bookingHasContainerTypeSql(alias = 'b'): string {
+  return `EXISTS (SELECT 1 FROM freight.booking_container bc
+                   WHERE bc.booking_id = ${alias}.id
+                     AND bc.deleted_at IS NULL
+                     AND bc.container_type_id = :containerTypeId)`;
+}
+
+/**
+ * Container VGM on a booking, in tons — the sum of the per-line totals.
+ *
+ * NOT `bookings.cargo_total_weight_vgm`: the portal wizard leaves that at 0 for
+ * container freight (VGM is captured per container, later, in operations), so
+ * reading the booking-level column showed every portal container booking as
+ * weighing nothing. Same reason `bookingTonsSql` falls through to these lines.
+ */
+export function bookingContainerVgmSql(alias = 'b'): string {
+  return `(SELECT COALESCE(SUM(bc.total_vgm_tons), 0)
+             FROM freight.booking_container bc
+            WHERE bc.booking_id = ${alias}.id
+              AND bc.deleted_at IS NULL)`;
+}
+
+/**
+ * Cargo the customer declared on the SHIPMENT REQUEST behind a booking, which
+ * is not the same fact as cargo on the booking itself.
+ *
+ * On a GENERAL + customs contract the customer cannot book directly: they
+ * submit a request (day + quantities), and `initiateForShipmentRequest` opens a
+ * BARE instance from it — "the request itself carries the quantities; the
+ * instance carries none". So between initiation and `completeUnderContract` the
+ * booking legitimately holds no cargo while the customer's declared quantities
+ * sit on `booking_requests.requested_lines`.
+ *
+ * Kept in its own column rather than folded into the real container count: a
+ * declared 2 × 20FT is a request, not two boxes on a booking, and merging the
+ * two would overstate operational totals.
+ */
+const REQUESTED_CONTAINER_LINES = `jsonb_array_elements(
+  CASE WHEN jsonb_typeof(br.requested_lines->'containers') = 'array'
+       THEN br.requested_lines->'containers'
+       ELSE '[]'::jsonb END)`;
+
+/** Human-readable declared cargo: "2 × 20FT", "12 t", "40 items". */
+export function bookingRequestedCargoSql(alias = 'b'): string {
+  return `(SELECT COALESCE(
+              (SELECT string_agg((l->>'quantity') || ' × ' || upper(l->>'containerSize'), ', '
+                                 ORDER BY l->>'containerSize')
+                 FROM ${REQUESTED_CONTAINER_LINES} AS l),
+              NULLIF(br.requested_lines->'bulk'->>'cargoWeightTons', '') || ' t',
+              NULLIF(br.requested_lines->'bulk'->>'itemCount', '') || ' items')
+            FROM freight.booking_requests br
+           WHERE br.created_booking_id = ${alias}.id
+             AND br.deleted_at IS NULL
+           ORDER BY br.created_at DESC
+           LIMIT 1)`;
+}
+
+/**
+ * Boxes declared on the shipment request. Pairs with the real container count:
+ * `Containers = 0` AND `Requested containers >= 1` is exactly the set awaiting
+ * completion.
+ */
+export function bookingRequestedContainerCountSql(alias = 'b'): string {
+  return `(SELECT COALESCE(SUM((l->>'quantity')::int), 0)
+             FROM freight.booking_requests br
+             CROSS JOIN LATERAL ${REQUESTED_CONTAINER_LINES} AS l
+            WHERE br.created_booking_id = ${alias}.id
+              AND br.deleted_at IS NULL)`;
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-tons.sql.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-tons.sql.spec.ts
new file mode 100644
index 000000000..07067c3ed
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/booking-tons.sql.spec.ts
@@ -0,0 +1,30 @@
+import { bookingTonsSql } from './booking-tons.sql';
+
+describe('bookingTonsSql', () => {
+  const sql = bookingTonsSql('b');
+
+  // The regression this exists for: a plain COALESCE stops at the portal's
+  // literal 0 for container bookings and reports them as weighing nothing.
+  it('treats a stored 0 as "no figure" on both booking-level columns', () => {
+    expect(sql).toContain('NULLIF(b.bulk_total_weight_tons, 0)');
+    expect(sql).toContain('NULLIF(b.cargo_total_weight_vgm, 0)');
+  });
+
+  it('falls back to the per-line container VGM, excluding soft-deleted lines', () => {
+    expect(sql).toContain('SUM(bc.total_vgm_tons)');
+    expect(sql).toContain('freight.booking_container bc');
+    expect(sql).toContain('bc.booking_id = b.id');
+    expect(sql).toContain('bc.deleted_at IS NULL');
+  });
+
+  it('never returns NULL, so callers may SUM it directly', () => {
+    expect(sql.trimEnd().endsWith('0)')).toBe(true);
+  });
+
+  it('rewrites every reference when embedded under another alias', () => {
+    const aliased = bookingTonsSql('bk');
+    expect(aliased).not.toMatch(/\bb\./);
+    expect(aliased).toContain('bk.cargo_total_weight_vgm');
+    expect(aliased).toContain('bc.booking_id = bk.id');
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-tons.sql.ts b/apps/edr-freight-api/src/modules/bookings/booking-tons.sql.ts
new file mode 100644
index 000000000..f3a8590a2
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/bookings/booking-tons.sql.ts
@@ -0,0 +1,26 @@
+/**
+ * SQL mirror of `bookingCargoTons()` (train-scheduling/train-capacity.util.ts).
+ *
+ * Three storage conventions share `bookings.cargo_total_weight_vgm`:
+ *  - BULK PER_TON  — the column holds tons.
+ *  - BULK PER_ITEM — the column holds an ITEM COUNT; the tons are in
+ *    `bulk_total_weight_tons`.
+ *  - CONTAINER     — the portal wizard captures VGM per line, not per booking,
+ *    and sends 0 (portal NewBookingPage: "containers carry NO weight at the
+ *    wizard"). The tons live in `booking_container.total_vgm_tons`. The
+ *    backoffice wizard does store a booking-level total, so both shapes exist
+ *    in the same table.
+ *
+ * Hence NULLIF on both columns: a plain
+ * `COALESCE(bulk_total_weight_tons, cargo_total_weight_vgm)` stops at the
+ * portal's 0 — COALESCE falls through on NULL, never on 0 — and every
+ * portal-created container booking reads as 0 tons in exports and reports.
+ */
+export function bookingTonsSql(alias = 'b'): string {
+  return `COALESCE(
+    NULLIF(${alias}.bulk_total_weight_tons, 0),
+    NULLIF(${alias}.cargo_total_weight_vgm, 0),
+    (SELECT SUM(bc.total_vgm_tons) FROM freight.booking_container bc
+      WHERE bc.booking_id = ${alias}.id AND bc.deleted_at IS NULL),
+    0)`;
+}
diff --git a/apps/edr-freight-api/src/modules/bookings/booking-wagon-cancellation.service.ts b/apps/edr-freight-api/src/modules/bookings/booking-wagon-cancellation.service.ts
index ac6fb5aa3..86b9dedc6 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-wagon-cancellation.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-wagon-cancellation.service.ts
@@ -836,15 +836,15 @@ export class BookingWagonCancellationService {
       )
       .where('alloc.booking_id = :bookingId', { bookingId })
       .getMany();
-    const loaded = allocations.filter(
-      (a) => a.status === 'LOADED' || a.status === 'DEPARTED',
-    );
     const remaining = allocations.filter(
       (a) => a.status !== 'LOADED' && a.status !== 'DEPARTED',
     );
-    if (!loaded.length) {
+    // A booking whose cargo never showed up at all (0 loaded) is cancelled the
+    // same way — the gate that holds the train does not care whether loading
+    // started, only that nothing is left unresolved.
+    if (!allocations.length) {
       throw new BadRequestException(
-        'Loading has not started for this booking — use the normal wagon cancellation flow.',
+        'This booking has no wagons on this schedule — use the normal wagon cancellation flow.',
       );
     }
     if (!remaining.length) {
@@ -1875,9 +1875,12 @@ export class BookingWagonCancellationService {
           // the same cargo); number/seal/VGM come from the override when given.
           units: sized.map((u, i) => ({
             containerNumber: replacement?.[i]?.containerNumber ?? u.containerNumber,
+            // A credit snapshot taken before seals were mandatory can carry
+            // none; the booking service normalizes the blank back to null
+            // rather than blocking the rebook of already-paid cargo.
             sealNumber: replacement
-              ? (replacement[i]?.sealNumber ?? undefined)
-              : (u.sealNumber ?? undefined),
+              ? (replacement[i]?.sealNumber ?? '')
+              : (u.sealNumber ?? ''),
             vgmTons: replacement?.[i]?.vgmTons ?? u.vgmTons,
             isHazardous: u.isHazardous,
             isReefer: u.isReefer,
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
index 885486031..5e0e3c994 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -21,6 +21,13 @@ import { ShippingLineCompany } from '../shipping-lines/entities/shipping-line-co
 import { ContractRateSnapshot } from '../contracts/entities/contract-rate-snapshot.entity';
 import { ContractRoute } from '../contracts/entities/contract-route.entity';
 import { applyDirectionScope } from '../user-trade-access/trade-scope.util';
+import {
+  CARGO_TYPE_SUBTREE_SQL,
+  bookingContainerCountSql,
+  bookingContentMatchSql,
+  bookingHasContainerTypeSql,
+  bookingRequestedContainerCountSql,
+} from './booking-content.sql';
 import { BookingCargoModifier } from './entities/booking-cargo-modifier.entity';
 import {
   BookingDocumentReview,
@@ -65,7 +72,17 @@ export interface BookingListFilterOptions {
   contractId?: string;
   contractType?: string;
   serviceTypeId?: string;
+  /** Cargo type OR cargo group — a group matches every commodity beneath it. */
   cargoTypeId?: string;
+  /** Contains-search over content: description, commodity name, container types. */
+  cargoText?: string;
+  /** Bookings carrying this container type; also scopes the container count. */
+  containerTypeId?: string;
+  containersMin?: number;
+  containersMax?: number;
+  /** Bounds on containers declared on the shipment request behind the booking. */
+  requestedContainersMin?: number;
+  requestedContainersMax?: number;
   freightType?: string;
   bookingType?: string;
   tradeDirection?: string;
@@ -1176,11 +1193,55 @@ export class BookingsRepository extends BaseRepository<Booking> {
         serviceTypeId: options.serviceTypeId,
       });
     }
+    // A group is selectable in the filter, not just a leaf commodity, so this
+    // matches the whole subtree — picking "Bulk" must return every commodity
+    // under it, the same drill-down the booking wizard offers, read back.
     if (options.cargoTypeId) {
-      qb.andWhere('booking.cargo_type_id = :cargoTypeId', {
+      qb.andWhere(`booking.cargo_type_id IN ${CARGO_TYPE_SUBTREE_SQL}`, {
         cargoTypeId: options.cargoTypeId,
       });
     }
+    if (options.cargoText) {
+      qb.andWhere(bookingContentMatchSql('booking'), {
+        cargoText: `%${options.cargoText}%`,
+      });
+    }
+    if (options.containerTypeId) {
+      qb.andWhere(bookingHasContainerTypeSql('booking'), {
+        containerTypeId: options.containerTypeId,
+      });
+    }
+    // One count filter, two questions: with a container type picked it counts
+    // that type, without one it counts every box on the booking.
+    if (options.containersMin != null || options.containersMax != null) {
+      const count = bookingContainerCountSql(
+        'booking',
+        Boolean(options.containerTypeId),
+      );
+      if (options.containersMin != null) {
+        qb.andWhere(`${count} >= :containersMin`, {
+          containersMin: options.containersMin,
+        });
+      }
+      if (options.containersMax != null) {
+        qb.andWhere(`${count} <= :containersMax`, {
+          containersMax: options.containersMax,
+        });
+      }
+    }
+    // Declared on the shipment request, not on the booking. Pairs with the
+    // count above: containers 0..0 AND requested >= 1 is the set awaiting
+    // completion after clearance.
+    if (options.requestedContainersMin != null) {
+      qb.andWhere(`${bookingRequestedContainerCountSql('booking')} >= :requestedContainersMin`, {
+        requestedContainersMin: options.requestedContainersMin,
+      });
+    }
+    if (options.requestedContainersMax != null) {
+      qb.andWhere(`${bookingRequestedContainerCountSql('booking')} <= :requestedContainersMax`, {
+        requestedContainersMax: options.requestedContainersMax,
+      });
+    }
     if (omit !== 'freightType' && options.freightType) {
       qb.andWhere('booking.freight_type = :freightType', {
         freightType: options.freightType,
diff --git a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
index b6047633a..71107650f 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -1845,6 +1845,12 @@ export class BookingsService {
       contractType: filter.contractType,
       serviceTypeId: filter.serviceTypeId,
       cargoTypeId: filter.cargoTypeId,
+      cargoText: filter.cargoText,
+      containerTypeId: filter.containerTypeId,
+      containersMin: filter.containersMin,
+      containersMax: filter.containersMax,
+      requestedContainersMin: filter.requestedContainersMin,
+      requestedContainersMax: filter.requestedContainersMax,
       freightType: filter.freightType,
       bookingType: filter.bookingType,
       tradeDirection: filter.tradeDirection,
@@ -2072,6 +2078,12 @@ export class BookingsService {
       contractType: filter.contractType,
       serviceTypeId: filter.serviceTypeId,
       cargoTypeId: filter.cargoTypeId,
+      cargoText: filter.cargoText,
+      containerTypeId: filter.containerTypeId,
+      containersMin: filter.containersMin,
+      containersMax: filter.containersMax,
+      requestedContainersMin: filter.requestedContainersMin,
+      requestedContainersMax: filter.requestedContainersMax,
       freightType: filter.freightType,
       bookingType: filter.bookingType,
       tradeDirection: filter.tradeDirection,
diff --git a/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts b/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts
index a404c005e..a6138e77b 100644
--- a/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts
+++ b/apps/edr-freight-api/src/modules/bookings/dto/filter-booking.dto.ts
@@ -62,11 +62,60 @@ export class FilterBookingDto {
   @IsUUID()
   serviceTypeId?: string;
 
-  @ApiPropertyOptional({ format: 'uuid' })
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description:
+      'Cargo type OR cargo group — a group matches every commodity beneath it',
+  })
   @IsOptional()
   @IsUUID()
   cargoTypeId?: string;
 
+  @ApiPropertyOptional({
+    description:
+      'Contains-search over booking content: cargo description, commodity name, container types',
+  })
+  @IsOptional()
+  @Transform(({ value }) =>
+    typeof value === 'string' && value.trim() ? value.trim() : undefined,
+  )
+  cargoText?: string;
+
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description:
+      'Bookings carrying this container type. Also scopes containersMin/Max to it.',
+  })
+  @IsOptional()
+  @IsUUID()
+  containerTypeId?: string;
+
+  @ApiPropertyOptional({
+    description:
+      'Minimum container count — of containerTypeId when set, else of all types',
+  })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  containersMin?: number;
+
+  @ApiPropertyOptional({ description: 'Maximum container count — see containersMin' })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  containersMax?: number;
+
+  @ApiPropertyOptional({
+    description:
+      'Minimum containers declared on the shipment request behind the booking',
+  })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  requestedContainersMin?: number;
+
+  @ApiPropertyOptional({ description: 'Maximum requested containers — see requestedContainersMin' })
+  @IsOptional()
+  @Transform(({ value }) => (value === '' || value == null ? undefined : Number(value)))
+  requestedContainersMax?: number;
+
   @ApiPropertyOptional({ enum: FREIGHT_TYPES })
   @IsOptional()
   @IsIn([...FREIGHT_TYPES])
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
index f5e00f503..88a2175b9 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-booking.service.ts
@@ -2250,7 +2250,9 @@ export class ContractBookingService {
           unitRepo.create({
             bookingContainerId: containerRow.id,
             containerNumber: unit.containerNumber,
-            sealNumber: unit.sealNumber ?? null,
+            // Legacy units recovered by the remainder placement can still
+            // arrive sealless — keep those null rather than empty-string.
+            sealNumber: unit.sealNumber?.trim() || null,
             vgmTons: unit.vgmTons,
             isHazardous: unit.isHazardous ?? false,
             isReefer: unit.isReefer ?? false,
diff --git a/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts b/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts
index 0592dafc4..b1dabfa16 100644
--- a/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts
+++ b/apps/edr-freight-api/src/modules/contracts/dto/create-booking-under-contract.dto.ts
@@ -7,6 +7,7 @@ import {
   IsEmail,
   IsIn,
   IsInt,
+  IsNotEmpty,
   IsNumber,
   IsOptional,
   IsString,
@@ -32,10 +33,12 @@ export class CreateContainerUnitDto {
   })
   containerNumber!: string;
 
-  @ApiPropertyOptional()
-  @IsOptional()
+  @ApiProperty({ description: 'Seal number — required on every container, import and export alike.' })
   @IsString()
-  sealNumber?: string;
+  @Transform(({ value }) => (typeof value === 'string' ? value.trim() : value))
+  @IsNotEmpty({ message: 'sealNumber is required' })
+  @MaxLength(64)
+  sealNumber!: string;
 
   @ApiProperty({ description: 'VGM in tons', minimum: 0 })
   @IsNumber()
diff --git a/apps/edr-freight-api/src/modules/exports/datasets/bookings.dataset.ts b/apps/edr-freight-api/src/modules/exports/datasets/bookings.dataset.ts
index c9f2a7d21..69ff22927 100644
--- a/apps/edr-freight-api/src/modules/exports/datasets/bookings.dataset.ts
+++ b/apps/edr-freight-api/src/modules/exports/datasets/bookings.dataset.ts
@@ -1,4 +1,17 @@
+import { DataSource } from 'typeorm';
+
 import { FREIGHT_PERMS } from '../../../seed/freight-permissions.registry';
+import {
+  CARGO_TYPE_SUBTREE_SQL,
+  bookingContainerCountSql,
+  bookingContentMatchSql,
+  bookingContainerVgmSql,
+  bookingContentSql,
+  bookingHasContainerTypeSql,
+  bookingRequestedCargoSql,
+  bookingRequestedContainerCountSql,
+} from '../../bookings/booking-content.sql';
+import { bookingTonsSql } from '../../bookings/booking-tons.sql';
 import { Booking } from '../../bookings/entities/booking.entity';
 import { Company } from '../../companies/entities/company.entity';
 import { CompanyProfile } from '../../companies/entities/company-profile.entity';
@@ -10,23 +23,104 @@ import { Yard } from '../../rule-engine/entities/yard.entity';
 import { ShippingLineCompany } from '../../shipping-lines/entities/shipping-line-company.entity';
 import { Train } from '../../trains/entities/train.entity';
 import { applyDirectionScope } from '../../user-trade-access/trade-scope.util';
-import { ExportDataset } from '../export.types';
+import { ExportFilterOption } from '../export-filter.util';
+import { ExportDataset, ExportField } from '../export.types';
 
 /**
  * Domain semantics that the retired `bookings-list` report used to share.
- * Kept identical on purpose — for PER_ITEM bulk bookings `cargo_total_weight_vgm`
- * holds an item COUNT, not tonnage, and `adjusted_total_amount` silently
- * overrides `total_amount`. Getting either wrong misreports money or weight.
+ * Tonnage is `bookingTonsSql` — the one resolver for the three ways a booking
+ * stores its weight. `adjusted_total_amount` silently overrides `total_amount`.
+ * Getting either wrong misreports money or weight.
  */
-const TONS = 'COALESCE(b.bulk_total_weight_tons, b.cargo_total_weight_vgm)';
+const TONS = bookingTonsSql('b');
 const REVENUE = 'COALESCE(b.adjusted_total_amount, b.total_amount)';
 
+/** What the customer described as the booking's contents — see the helper. */
+const CONTENT = bookingContentSql('b');
+const CONTAINER_COUNT = bookingContainerCountSql('b');
+const REQUESTED_COUNT = bookingRequestedContainerCountSql('b');
+
 const STATUS_OPTIONS = [
   'DRAFT', 'SUBMITTED', 'UNDER_REVIEW', 'APPROVED', 'REJECTED',
   'CANCELLED', 'EXPIRED', 'SCHEDULED', 'LOADED', 'IN_TRANSIT',
   'ARRIVED', 'DELIVERED', 'COMPLETED',
 ].map((v) => ({ value: v, label: v.replace(/_/g, ' ') }));
 
+/**
+ * Cargo tree flattened for a single select: groups and every commodity beneath
+ * them, each labelled by its full path ("Bulk → Wheat") the way the booking
+ * wizard shows a deep leaf. Picking a group row filters its whole subtree.
+ *
+ * Recursive because `cargo_types` is arbitrary-depth, not two levels.
+ */
+async function cargoTypeOptions(ds: DataSource): Promise<ExportFilterOption[]> {
+  return ds.query(`
+    WITH RECURSIVE t AS (
+      SELECT id, display_order, 0 AS depth,
+             ARRAY[display_order]::int[] AS ord,
+             ARRAY[cargo_type_name]::text[] AS path
+        FROM freight.cargo_types
+       WHERE parent_group_id IS NULL AND deleted_at IS NULL AND is_active
+      UNION ALL
+      SELECT c.id, c.display_order, t.depth + 1,
+             t.ord || c.display_order,
+             t.path || c.cargo_type_name
+        FROM freight.cargo_types c
+        JOIN t ON c.parent_group_id = t.id
+       WHERE c.deleted_at IS NULL AND c.is_active
+    )
+    SELECT id AS value, array_to_string(path, ' → ') AS label
+      FROM t ORDER BY ord, path
+  `) as Promise<ExportFilterOption[]>;
+}
+
+/** Container types are 2 rows that change about never. */
+async function containerTypeOptions(ds: DataSource): Promise<ExportFilterOption[]> {
+  return ds.query(`
+    SELECT id AS value, COALESCE(label, code) AS label
+      FROM freight.container_types
+     WHERE deleted_at IS NULL AND is_active
+     ORDER BY display_order, code
+  `) as Promise<ExportFilterOption[]>;
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+/**
+ * One column per container type ("20FT", "40FT", …), each the box count of
+ * that type on the booking. Resolved from `container_types` rather than
+ * hardcoded, so adding a 45ft adds its column without a deploy of this file.
+ *
+ * The type id is INTERPOLATED, not bound — `ExportField.select` is a raw SQL
+ * string with no parameter bag — so ids that are not uuids are dropped rather
+ * than spliced. They come from our own table; the guard is for the day someone
+ * changes that column's type.
+ */
+async function containerTypeFields(ds: DataSource): Promise<ExportField[]> {
+  const rows: Array<{ id: string; code: string; label: string | null }> = await ds.query(`
+    SELECT id, code, label
+      FROM freight.container_types
+     WHERE deleted_at IS NULL AND is_active
+     ORDER BY display_order, code
+  `);
+  return rows
+    .filter((r) => UUID_RE.test(r.id))
+    .map((r) => {
+      const name = r.label || r.code;
+      return {
+        key: `containers${r.code.replace(/[^A-Za-z0-9]/g, '')}`,
+        label: `${name} containers`,
+        type: 'number' as const,
+        group: 'cargo',
+        select: `(SELECT COALESCE(SUM(bc.quantity), 0)
+                    FROM freight.booking_container bc
+                   WHERE bc.booking_id = b.id
+                     AND bc.deleted_at IS NULL
+                     AND bc.container_type_id = '${r.id}')::int`,
+      };
+    });
+}
+
 export const bookingsDataset: ExportDataset = {
   key: 'bookings',
   title: 'Bookings',
@@ -112,10 +206,21 @@ export const bookingsDataset: ExportDataset = {
     { key: 'serviceType', label: 'Service type', type: 'string', group: 'route', requires: ['st'], select: 'st.service_name' },
 
     // ---- Cargo -----------------------------------------------------------
-    { key: 'cargo', label: 'Cargo', type: 'string', group: 'cargo', default: true, requires: ['cty'], select: 'COALESCE(cty.cargo_type_name, b.cargo_free_text)' },
+    // What the customer said is in the booking. `cargo` below is the narrower
+    // commodity-only view, kept for saved presets that already tick it.
+    { key: 'content', label: 'Content', type: 'string', group: 'cargo', default: true, select: CONTENT, sortExpr: CONTENT },
+    { key: 'cargo', label: 'Cargo (commodity)', type: 'string', group: 'cargo', requires: ['cty'], select: 'COALESCE(cty.cargo_type_name, b.cargo_free_text)' },
+    { key: 'cargoDescription', label: 'Cargo description', type: 'string', group: 'cargo', select: 'b.cargo_free_text' },
+    // Boxes, not lines: booking_container is one row per LINE with a quantity.
+    { key: 'containerCount', label: 'Containers', type: 'number', group: 'cargo', default: true, select: `${CONTAINER_COUNT}::int`, sortExpr: CONTAINER_COUNT },
+    // Declared on the shipment request, not yet on the booking — see the helper.
+    { key: 'requestedCargo', label: 'Requested cargo', type: 'string', group: 'cargo', select: bookingRequestedCargoSql('b') },
+    { key: 'requestedContainers', label: 'Requested containers', type: 'number', group: 'cargo', select: `${REQUESTED_COUNT}::int`, sortExpr: REQUESTED_COUNT },
     { key: 'freightType', label: 'Freight type', type: 'string', group: 'cargo', default: true, select: 'b.freight_type' },
     { key: 'tons', label: 'Tonnage', type: 'tons', group: 'cargo', default: true, select: `ROUND(${TONS})::float8`, sortExpr: TONS },
-    { key: 'containerWeightVgm', label: 'Container VGM', type: 'number', group: 'cargo', select: 'b.cargo_total_weight_vgm' },
+    // The per-line sum, NOT b.cargo_total_weight_vgm — the portal leaves that
+    // column at 0 for container freight, so it read 0 for every such booking.
+    { key: 'containerWeightVgm', label: 'Container VGM (t)', type: 'tons', group: 'cargo', select: `${bookingContainerVgmSql('b')}::float8`, sortExpr: bookingContainerVgmSql('b') },
     { key: 'bulkWeightTons', label: 'Bulk weight (t)', type: 'tons', group: 'cargo', select: 'b.bulk_total_weight_tons' },
     { key: 'isHazardous', label: 'Hazardous', type: 'boolean', group: 'cargo', select: 'b.is_hazardous' },
     { key: 'isReefer', label: 'Reefer', type: 'boolean', group: 'cargo', select: 'b.is_reefer' },
@@ -172,6 +277,8 @@ export const bookingsDataset: ExportDataset = {
     { key: 'doubleHandling', label: 'Double handling', type: 'boolean', group: 'clearance', select: 'b.double_handling' },
   ],
 
+  dynamicFields: containerTypeFields,
+
   filters: [
     { key: 'created', label: 'Created', type: 'daterange' },
     { key: 'statuses', label: 'Status', type: 'multiselect', options: STATUS_OPTIONS },
@@ -190,6 +297,13 @@ export const bookingsDataset: ExportDataset = {
       { value: 'PAID', label: 'Paid' },
       { value: 'FAILED', label: 'Failed' },
     ] },
+    { key: 'cargoTypeId', label: 'Content (cargo type)', type: 'select', optionsQuery: cargoTypeOptions },
+    { key: 'cargoText', label: 'Content contains', type: 'text' },
+    { key: 'containerTypeId', label: 'Container type', type: 'select', optionsQuery: containerTypeOptions },
+    { key: 'containersMin', label: 'Containers (min)', type: 'text' },
+    { key: 'containersMax', label: 'Containers (max)', type: 'text' },
+    { key: 'requestedContainersMin', label: 'Requested containers (min)', type: 'text' },
+    { key: 'requestedContainersMax', label: 'Requested containers (max)', type: 'text' },
     { key: 'companyId', label: 'Customer', type: 'text' },
     { key: 'search', label: 'Search reference or customer', type: 'text' },
   ],
@@ -210,6 +324,23 @@ export const bookingsDataset: ExportDataset = {
 
     if (params.tradeDirection) qb.andWhere('b.trade_direction = :tradeDirection', { tradeDirection: params.tradeDirection });
     if (params.freightType) qb.andWhere('b.freight_type = :freightType', { freightType: params.freightType });
+    // Group or leaf — a group matches its whole subtree (see CARGO_TYPE_SUBTREE_SQL).
+    if (params.cargoTypeId) qb.andWhere(`b.cargo_type_id IN ${CARGO_TYPE_SUBTREE_SQL}`, { cargoTypeId: params.cargoTypeId });
+    if (params.cargoText) qb.andWhere(bookingContentMatchSql('b'), { cargoText: `%${params.cargoText as string}%` });
+    if (params.containerTypeId) qb.andWhere(bookingHasContainerTypeSql('b'), { containerTypeId: params.containerTypeId });
+    // With a container type picked the count is of THAT type, else of every box.
+    const containerCount = bookingContainerCountSql('b', Boolean(params.containerTypeId));
+    // coerceFilterParams yields null (not undefined) for an unset filter, and
+    // Number(null) is 0 — which would silently apply ">= 0" to every export.
+    const num = (v: unknown) => (v == null || v === '' ? NaN : Number(v));
+    const min = num(params.containersMin);
+    const max = num(params.containersMax);
+    if (Number.isFinite(min)) qb.andWhere(`${containerCount} >= :containersMin`, { containersMin: min });
+    if (Number.isFinite(max)) qb.andWhere(`${containerCount} <= :containersMax`, { containersMax: max });
+    const reqMin = num(params.requestedContainersMin);
+    const reqMax = num(params.requestedContainersMax);
+    if (Number.isFinite(reqMin)) qb.andWhere(`${REQUESTED_COUNT} >= :requestedContainersMin`, { requestedContainersMin: reqMin });
+    if (Number.isFinite(reqMax)) qb.andWhere(`${REQUESTED_COUNT} <= :requestedContainersMax`, { requestedContainersMax: reqMax });
     if (params.paymentStatus) qb.andWhere('b.payment_status = :paymentStatus', { paymentStatus: params.paymentStatus });
     if (params.companyId) qb.andWhere('b.company_id = :companyId', { companyId: params.companyId });
     if (params.search) {
diff --git a/apps/edr-freight-api/src/modules/exports/datasets/invoices.dataset.ts b/apps/edr-freight-api/src/modules/exports/datasets/invoices.dataset.ts
index 56ab3b74e..d4d635f6f 100644
--- a/apps/edr-freight-api/src/modules/exports/datasets/invoices.dataset.ts
+++ b/apps/edr-freight-api/src/modules/exports/datasets/invoices.dataset.ts
@@ -123,6 +123,7 @@ export const invoicesDataset: ExportDataset = {
     // on-screen filter actually carries into the export.
     { key: 'status', label: 'Status (single)', type: 'text' },
     { key: 'sources', label: 'Source', type: 'multiselect' },
+    { key: 'types', label: 'Type', type: 'multiselect' },
     { key: 'eimsStatuses', label: 'EIMS status', type: 'multiselect' },
     { key: 'paymentMethods', label: 'Payment method', type: 'multiselect' },
     { key: 'currency', label: 'Currency', type: 'select', options: [
@@ -151,6 +152,8 @@ export const invoicesDataset: ExportDataset = {
     if (params.status) qb.andWhere('i.status = :status', { status: params.status });
     const sources = params.sources as string[] | null;
     if (sources?.length) qb.andWhere('i.source IN (:...sources)', { sources });
+    const types = params.types as string[] | null;
+    if (types?.length) qb.andWhere('i.type IN (:...types)', { types });
     const eimsStatuses = params.eimsStatuses as string[] | null;
     if (eimsStatuses?.length) qb.andWhere('i.eims_status IN (:...eimsStatuses)', { eimsStatuses });
     const paymentMethods = params.paymentMethods as string[] | null;
diff --git a/apps/edr-freight-api/src/modules/exports/datasets/train-schedules.dataset.ts b/apps/edr-freight-api/src/modules/exports/datasets/train-schedules.dataset.ts
index bb31591da..d380470de 100644
--- a/apps/edr-freight-api/src/modules/exports/datasets/train-schedules.dataset.ts
+++ b/apps/edr-freight-api/src/modules/exports/datasets/train-schedules.dataset.ts
@@ -1,4 +1,5 @@
 import { FREIGHT_PERMS } from '../../../seed/freight-permissions.registry';
+import { bookingTonsSql } from '../../bookings/booking-tons.sql';
 import { Route } from '../../routes/entities/route.entity';
 import { Yard } from '../../rule-engine/entities/yard.entity';
 import { ShippingLineCompany } from '../../shipping-lines/entities/shipping-line-company.entity';
@@ -86,7 +87,7 @@ export const trainSchedulesDataset: ExportDataset = {
     },
     {
       key: 'totalWeightTons', label: 'Total weight (t)', type: 'tons', group: 'load', default: true,
-      select: `(SELECT ROUND(COALESCE(SUM(COALESCE(b.bulk_total_weight_tons, b.cargo_total_weight_vgm)), 0))::float8
+      select: `(SELECT ROUND(COALESCE(SUM(${bookingTonsSql('b')}), 0))::float8
                 FROM freight.bookings b
                 WHERE b.train_schedule_id = sch.id AND b.deleted_at IS NULL)`,
     },
diff --git a/apps/edr-freight-api/src/modules/exports/export-filter.util.ts b/apps/edr-freight-api/src/modules/exports/export-filter.util.ts
index c302d9d3b..40c8e6980 100644
--- a/apps/edr-freight-api/src/modules/exports/export-filter.util.ts
+++ b/apps/edr-freight-api/src/modules/exports/export-filter.util.ts
@@ -1,5 +1,7 @@
 import { DataSource } from 'typeorm';
 
+import type { ExportField } from './export.types';
+
 const DAY_MS = 24 * 60 * 60 * 1000;
 
 export type ExportFilterType = 'daterange' | 'date' | 'select' | 'multiselect' | 'text';
@@ -64,6 +66,26 @@ export function coerceFilterParams(
  */
 const optionsCache = new Map<string, ExportFilterOption[]>();
 
+/** Process-lifetime cache for `dynamicFields`, keyed by dataset. */
+const fieldsCache = new Map<string, ExportField[]>();
+
+/**
+ * A dataset's full field list: its static fields plus whatever `dynamicFields`
+ * resolves from the DB. Every read of `dataset.fields` goes through this, so
+ * the catalog and the download agree on which keys exist.
+ */
+export async function resolveDatasetFields(
+  dataset: { key: string; fields: ExportField[]; dynamicFields?: (ds: DataSource) => Promise<ExportField[]> },
+  ds: DataSource,
+): Promise<ExportField[]> {
+  if (!dataset.dynamicFields) return dataset.fields;
+  const cached = fieldsCache.get(dataset.key);
+  if (cached) return cached;
+  const resolved = [...dataset.fields, ...(await dataset.dynamicFields(ds))];
+  fieldsCache.set(dataset.key, resolved);
+  return resolved;
+}
+
 export async function resolveFilterOptions(
   filters: ExportFilterDef[],
   ds: DataSource,
diff --git a/apps/edr-freight-api/src/modules/exports/export.types.ts b/apps/edr-freight-api/src/modules/exports/export.types.ts
index db12f0211..71abdad88 100644
--- a/apps/edr-freight-api/src/modules/exports/export.types.ts
+++ b/apps/edr-freight-api/src/modules/exports/export.types.ts
@@ -103,6 +103,15 @@ export interface ExportDataset {
   alwaysJoin?: string[];
   groups: ExportGroup[];
   fields: ExportField[];
+  /**
+   * Extra fields resolved from reference data and appended to `fields` — one
+   * column per row of some small, rarely-changing table (a column per container
+   * type, say). Cached for the process, like `ExportFilterDef.optionsQuery`.
+   *
+   * The SQL these build is interpolated, not bound, so a resolver MUST validate
+   * anything it splices in; see `bookingsDataset` for the uuid guard.
+   */
+  dynamicFields?: (ds: DataSource) => Promise<ExportField[]>;
   filters: ExportFilterDef[];
   /** Must name a field whose `sortExpr` references only the base alias. */
   defaultSort?: { key: string; dir: 'ASC' | 'DESC' };
diff --git a/apps/edr-freight-api/src/modules/exports/exports.controller.ts b/apps/edr-freight-api/src/modules/exports/exports.controller.ts
index aea35a9bc..46c6ebad2 100644
--- a/apps/edr-freight-api/src/modules/exports/exports.controller.ts
+++ b/apps/edr-freight-api/src/modules/exports/exports.controller.ts
@@ -9,7 +9,7 @@ import type { TCurrentUser } from '@tria-plc/api-common/modules/auth/types/curre
 
 import { assertFreightPermission, hasFreightPermission } from '../../common/freight-permission.util';
 import { UserTradeAccessService } from '../user-trade-access/user-trade-access.service';
-import { resolveFilterOptions } from './export-filter.util';
+import { resolveDatasetFields, resolveFilterOptions } from './export-filter.util';
 import {
   EXPORT_MIME,
   formatRowCap,
@@ -31,13 +31,16 @@ const CAPS = { csv: CSV_ROW_CAP, xlsx: XLSX_ROW_CAP, pdf: PDF_ROW_CAP };
  * Metadata only. `select` / `requires` / `sortExpr` are raw SQL and a map of
  * the schema — they never leave the server.
  */
-const toCatalogEntry = (dataset: ExportDataset): ExportCatalogEntry => ({
+const toCatalogEntry = (
+  dataset: ExportDataset,
+  fields: ExportField[],
+): ExportCatalogEntry => ({
   key: dataset.key,
   title: dataset.title,
   description: dataset.description,
   group: dataset.group,
   groups: dataset.groups,
-  fields: dataset.fields.map(({ key, label, type, group, default: isDefault }) => ({
+  fields: fields.map(({ key, label, type, group, default: isDefault }) => ({
     key,
     label,
     type,
@@ -72,7 +75,7 @@ export class ExportsController {
     const allowed = DATASETS.filter((d) => hasFreightPermission(user, d.permission));
     return Promise.all(
       allowed.map(async (d) => ({
-        ...toCatalogEntry(d),
+        ...toCatalogEntry(d, await resolveDatasetFields(d, this.dataSource)),
         filters: await resolveFilterOptions(d.filters, this.dataSource),
       })),
     );
@@ -102,7 +105,10 @@ export class ExportsController {
     const dataset = this.resolve(key, user);
     const directions = await this.userTradeAccessService.resolveAllowedDirections(user);
     const format = resolveExportFormat(query.format);
-    const fields = this.resolveFields(dataset, query.fields);
+    const fields = ExportsController.pickFields(
+      await resolveDatasetFields(dataset, this.dataSource),
+      query.fields,
+    );
 
     const rows = await this.runner.run(dataset, fields, query, directions, {
       cap: formatRowCap(format),
@@ -134,15 +140,15 @@ export class ExportsController {
    * DEFAULT set, not everything — a booking export has ~70 fields and dumping
    * all of them on an unparameterised call is nobody's intent.
    */
-  private resolveFields(dataset: ExportDataset, raw: string | undefined): ExportField[] {
+  private static pickFields(all: ExportField[], raw: string | undefined): ExportField[] {
     if (raw?.trim()) {
-      const picked = pickByKey(dataset.fields, raw);
+      const picked = pickByKey(all, raw);
       // pickByKey falls back to everything when nothing matched; for a dataset
       // the safer read of "all keys unknown" is still the default set.
-      if (picked.length !== dataset.fields.length) return picked;
+      if (picked.length !== all.length) return picked;
     }
-    const defaults = dataset.fields.filter((f) => f.default);
-    return defaults.length ? defaults : dataset.fields;
+    const defaults = all.filter((f) => f.default);
+    return defaults.length ? defaults : all;
   }
 
   private resolve(key: string, user: TCurrentUser): ExportDataset {
diff --git a/apps/edr-freight-api/src/modules/import-operations/dto/import-operations.dto.ts b/apps/edr-freight-api/src/modules/import-operations/dto/import-operations.dto.ts
index 9af97f1e8..92a5a611a 100644
--- a/apps/edr-freight-api/src/modules/import-operations/dto/import-operations.dto.ts
+++ b/apps/edr-freight-api/src/modules/import-operations/dto/import-operations.dto.ts
@@ -1,6 +1,8 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { Type } from 'class-transformer';
 import {
+  ArrayMaxSize,
+  ArrayMinSize,
   ArrayNotEmpty,
   IsArray,
   IsDateString,
@@ -9,6 +11,7 @@ import {
   IsOptional,
   IsString,
   IsUUID,
+  MaxLength,
   Min,
   ValidateNested,
 } from 'class-validator';
@@ -150,6 +153,14 @@ export class CreateEmptyContainerReturnDto {
   @IsUUID()
   customerId?: string;
 
+  @ApiPropertyOptional({
+    description: 'Owning company name — free text when the company is not a registered customer.',
+  })
+  @IsOptional()
+  @IsString()
+  @MaxLength(200)
+  companyName?: string;
+
   @ApiPropertyOptional()
   @IsOptional()
   @IsDateString()
@@ -196,6 +207,16 @@ export class CreateEmptyContainerReturnDto {
   returnedBy?: 'EDR' | 'CUSTOMER';
 }
 
+export class BulkCreateEmptyContainerReturnsDto {
+  @ApiProperty({ type: [CreateEmptyContainerReturnDto] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @ArrayMaxSize(1000)
+  @ValidateNested({ each: true })
+  @Type(() => CreateEmptyContainerReturnDto)
+  returns!: CreateEmptyContainerReturnDto[];
+}
+
 export class LoadEmptyContainerItemDto {
   @ApiProperty({ format: 'uuid' })
   @IsUUID()
diff --git a/apps/edr-freight-api/src/modules/import-operations/entities/empty-container-return.entity.ts b/apps/edr-freight-api/src/modules/import-operations/entities/empty-container-return.entity.ts
index 263dd30d2..230581dd4 100644
--- a/apps/edr-freight-api/src/modules/import-operations/entities/empty-container-return.entity.ts
+++ b/apps/edr-freight-api/src/modules/import-operations/entities/empty-container-return.entity.ts
@@ -27,6 +27,15 @@ export class EmptyContainerReturn extends BaseEntity {
   @Column({ name: 'customer_id', type: 'uuid', nullable: true })
   customerId?: string | null;
 
+  /**
+   * Owning company as text. Set when the box was backfilled for a company that
+   * is not (yet) a registered customer, so `customer_id` cannot carry it. When
+   * a registered company IS picked, both are set — the name is the label the
+   * list renders without a join.
+   */
+  @Column({ name: 'company_name', type: 'varchar', length: 200, nullable: true })
+  companyName?: string | null;
+
   @Column({ name: 'return_date', type: 'timestamptz' })
   returnDate!: Date;
 
@@ -75,3 +84,14 @@ export class EmptyContainerReturn extends BaseEntity {
     performedBy: string | null;
   }>;
 }
+
+/**
+ * A row of the returns list: the entity's own columns plus the booking
+ * reference and owning company joined in. Standalone returns leave
+ * `bookingId`/`bookingReference` null.
+ */
+export interface EmptyContainerReturnListItem
+  extends Omit<EmptyContainerReturn, 'createdAt' | 'updatedAt' | 'deletedAt'> {
+  bookingReference: string | null;
+  createdAt: Date;
+}
diff --git a/apps/edr-freight-api/src/modules/import-operations/import-operations.controller.ts b/apps/edr-freight-api/src/modules/import-operations/import-operations.controller.ts
index ae80ea9c8..1116e9440 100644
--- a/apps/edr-freight-api/src/modules/import-operations/import-operations.controller.ts
+++ b/apps/edr-freight-api/src/modules/import-operations/import-operations.controller.ts
@@ -11,6 +11,7 @@ import { BookingsService } from '../bookings/bookings.service';
 import {
   AssignCustomsRiskDto,
   CreateDjiboutiIncidentDto,
+  BulkCreateEmptyContainerReturnsDto,
   CreateEmptyContainerReturnDto,
   ImportOperationActionDto,
   LoadEmptyContainersOnTrainDto,
@@ -125,6 +126,15 @@ export class ImportOperationsController {
     return this.service.createEmptyReturn(dto);
   }
 
+  @Post('empty-container-returns/bulk')
+  @BookingStaff(FREIGHT_PERMS.bookings.operations)
+  @ApiOperation({
+    summary: 'Bulk-record empties already in the yard but never entered in the system',
+  })
+  bulkCreateEmptyReturns(@Body() dto: BulkCreateEmptyContainerReturnsDto) {
+    return this.service.bulkCreateEmptyReturns(dto);
+  }
+
   @Post('empty-container-returns/load-on-train')
   @BookingStaff(FREIGHT_PERMS.bookings.operations)
   @ApiOperation({
diff --git a/apps/edr-freight-api/src/modules/import-operations/import-operations.service.ts b/apps/edr-freight-api/src/modules/import-operations/import-operations.service.ts
index be94e3f32..9a84a0551 100644
--- a/apps/edr-freight-api/src/modules/import-operations/import-operations.service.ts
+++ b/apps/edr-freight-api/src/modules/import-operations/import-operations.service.ts
@@ -1,6 +1,6 @@
 import { BadRequestException, Injectable, Logger, NotFoundException } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { In, Repository } from 'typeorm';
+import { In, Not, Repository } from 'typeorm';
 
 import { NotificationAudience, NotificationType } from '@edr/types';
 import { LogoSettingsService } from '../logo-settings/logo-settings.service';
@@ -10,6 +10,7 @@ import { NotificationsService } from '../notifications/notifications.service';
 import { sendCompanyChannels } from '../notifications/notify-company.util';
 import { WarehouseReleaseDocumentService } from '../warehouses/warehouse-release-document.service';
 import {
+  BulkCreateEmptyContainerReturnsDto,
   CreateDjiboutiIncidentDto,
   CreateEmptyContainerReturnDto,
   ImportOperationActionDto,
@@ -24,7 +25,11 @@ import {
   type DjiboutiIncidentType,
 } from './entities/djibouti-incident.entity';
 import { assertWagonLoad } from './empty-container-wagon.util';
-import { EmptyContainerReturn } from './entities/empty-container-return.entity';
+import {
+  EmptyContainerReturn,
+  type EmptyContainerReturnListItem,
+  type EmptyContainerReturnStatus,
+} from './entities/empty-container-return.entity';
 import {
   ImportCustomsFinalization,
   type ImportCustomsDocumentType,
@@ -159,8 +164,43 @@ export class ImportOperationsService {
     return this.getCustoms(bookingId);
   }
 
-  listEmptyReturns() {
-    return this.emptyReturns.find({ order: { createdAt: 'DESC' } as never });
+  /**
+   * Every empty return, booking-linked and standalone alike, in one list. The
+   * booking reference and the owning company are joined in so the table can
+   * show which booking a box came back on without a second round trip — a
+   * standalone row simply has neither, and falls back to the typed
+   * `company_name`.
+   */
+  listEmptyReturns(): Promise<EmptyContainerReturnListItem[]> {
+    return this.emptyReturns.manager.query(`
+      SELECT
+        r.id,
+        r.container_number AS "containerNumber",
+        r.booking_id AS "bookingId",
+        b.reference AS "bookingReference",
+        r.customer_id AS "customerId",
+        COALESCE(r.company_name, c.name) AS "companyName",
+        r.return_date AS "returnDate",
+        r.facility,
+        r.yard,
+        r.zone,
+        r.condition,
+        r.handover_note AS "handoverNote",
+        r.status,
+        r.wagon_allocation_reference AS "wagonAllocationReference",
+        r.container_size AS "containerSize",
+        r.train_schedule_id AS "trainScheduleId",
+        r.wagon_sequence_no AS "wagonSequenceNo",
+        r.performed_by AS "performedBy",
+        r.returned_by AS "returnedBy",
+        r.status_history AS "statusHistory",
+        r.created_at AS "createdAt"
+      FROM freight.empty_container_returns r
+      LEFT JOIN freight.bookings b ON b.id = r.booking_id
+      LEFT JOIN freight.companies c ON c.id = b.company_id
+      WHERE r.deleted_at IS NULL
+      ORDER BY r.created_at DESC
+    `);
   }
 
   listEmptyReturnsForBooking(bookingId: string) {
@@ -174,6 +214,7 @@ export class ImportOperationsService {
         containerNumber: dto.containerNumber,
         bookingId: dto.bookingId ?? null,
         customerId: dto.customerId ?? null,
+        companyName: dto.companyName ?? null,
         returnDate,
         containerSize: dto.containerSize ?? null,
         facility: dto.facility ?? null,
@@ -199,6 +240,66 @@ export class ImportOperationsService {
     return saved;
   }
 
+  /**
+   * Bulk backfill of empties already sitting in a yard but never recorded.
+   * All-or-nothing: if any container number already has an open (not COMPLETED)
+   * return, nothing is written — re-uploading the same sheet must not duplicate
+   * boxes. No interchange notification is sent; these are historical rows, not
+   * a live handover.
+   */
+  async bulkCreateEmptyReturns(dto: BulkCreateEmptyContainerReturnsDto) {
+    const numbers = dto.returns.map((r) => r.containerNumber.trim().toUpperCase());
+
+    const seen = new Set<string>();
+    const dupInFile = numbers.filter((n) => (seen.has(n) ? true : (seen.add(n), false)));
+    if (dupInFile.length > 0) {
+      throw new BadRequestException(
+        `Container number(s) repeated in the upload: ${[...new Set(dupInFile)].join(', ')}`,
+      );
+    }
+
+    const existing = await this.emptyReturns.find({
+      where: {
+        containerNumber: In(numbers),
+        status: Not('COMPLETED' as EmptyContainerReturnStatus),
+      },
+      select: { containerNumber: true },
+    });
+    if (existing.length > 0) {
+      throw new BadRequestException(
+        `Already recorded as returned: ${existing.map((r) => r.containerNumber).join(', ')}`,
+      );
+    }
+
+    const rows = dto.returns.map((r, i) => {
+      const returnDate = r.returnDate ? new Date(r.returnDate) : new Date();
+      return this.emptyReturns.create({
+        containerNumber: numbers[i],
+        bookingId: r.bookingId ?? null,
+        customerId: r.customerId ?? null,
+        companyName: r.companyName ?? null,
+        returnDate,
+        containerSize: r.containerSize ?? null,
+        facility: r.facility ?? null,
+        yard: r.yard ?? null,
+        zone: r.zone ?? null,
+        condition: r.condition ?? null,
+        handoverNote: r.handoverNote ?? null,
+        performedBy: r.performedBy ?? null,
+        returnedBy: r.returnedBy ?? null,
+        statusHistory: [
+          {
+            status: 'RETURNED' as const,
+            changedAt: returnDate.toISOString(),
+            performedBy: r.performedBy ?? null,
+          },
+        ],
+      });
+    });
+
+    return this.emptyReturns.save(rows);
+  }
+
   /**
    * Load returned empties onto an export departure. A wagon takes ONE 40ft or
    * TWO 20ft — never a mix, never three. Empties already sitting on a wagon of
diff --git a/apps/edr-freight-api/src/modules/reports/definitions/booking-status-breakdown.report.ts b/apps/edr-freight-api/src/modules/reports/definitions/booking-status-breakdown.report.ts
index 449c47181..c70fcb13f 100644
--- a/apps/edr-freight-api/src/modules/reports/definitions/booking-status-breakdown.report.ts
+++ b/apps/edr-freight-api/src/modules/reports/definitions/booking-status-breakdown.report.ts
@@ -1,6 +1,7 @@
 import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
 
 import { BookingStatus } from '@edr/types';
+import { bookingTonsSql } from '../../bookings/booking-tons.sql';
 import { Booking } from '../../bookings/entities/booking.entity';
 import { Yard } from '../../rule-engine/entities/yard.entity';
 import { CargoType } from '../../rule-engine/entities/cargo-type.entity';
@@ -9,7 +10,7 @@ import { ReportContext, ReportDefinition } from '../report.types';
 // One resolver behind "Booking per status, per port/train/date/cargo/contract
 // type" — the same breakdown Operation, Marketing, Global Logistics and the
 // Operation Report each ask for verbatim. Embed once, reuse everywhere.
-const TONS = 'COALESCE(b.bulk_total_weight_tons, b.cargo_total_weight_vgm)';
+const TONS = bookingTonsSql('b');
 const REVENUE = 'COALESCE(b.adjusted_total_amount, b.total_amount)';
 
 const STATUS_OPTIONS = [...new Set(Object.values(BookingStatus))].map((v) => ({
diff --git a/apps/edr-freight-api/src/modules/reports/definitions/cargo-summary.report.ts b/apps/edr-freight-api/src/modules/reports/definitions/cargo-summary.report.ts
index ee3063ee1..2df862f3c 100644
--- a/apps/edr-freight-api/src/modules/reports/definitions/cargo-summary.report.ts
+++ b/apps/edr-freight-api/src/modules/reports/definitions/cargo-summary.report.ts
@@ -1,9 +1,10 @@
 import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
 
+import { bookingTonsSql } from '../../bookings/booking-tons.sql';
 import { Booking } from '../../bookings/entities/booking.entity';
 import { ReportContext, ReportDefinition } from '../report.types';
 
-const TONS = 'COALESCE(b.bulk_total_weight_tons, b.cargo_total_weight_vgm)';
+const TONS = bookingTonsSql('b');
 const NOT_UMBRELLA = "(b.contract_kind IS NULL OR b.contract_kind <> 'GENERAL')";
 const DEAD_STATUSES = ['DRAFT', 'CANCELLED', 'REJECTED', 'EXPIRED'];
 
diff --git a/apps/edr-freight-api/src/modules/reports/definitions/contract-utilization.report.ts b/apps/edr-freight-api/src/modules/reports/definitions/contract-utilization.report.ts
index 747a14891..64598fa87 100644
--- a/apps/edr-freight-api/src/modules/reports/definitions/contract-utilization.report.ts
+++ b/apps/edr-freight-api/src/modules/reports/definitions/contract-utilization.report.ts
@@ -1,10 +1,11 @@
 import { ObjectLiteral, SelectQueryBuilder } from 'typeorm';
 
+import { bookingTonsSql } from '../../bookings/booking-tons.sql';
 import { Company } from '../../companies/entities/company.entity';
 import { Contract } from '../../contracts/entities/contract.entity';
 import { ReportContext, ReportDefinition } from '../report.types';
 
-const TONS = 'COALESCE(b.bulk_total_weight_tons, b.cargo_total_weight_vgm)';
+const TONS = bookingTonsSql('b');
 const DEAD_STATUSES = ['DRAFT', 'CANCELLED', 'REJECTED', 'EXPIRED'];
 
 function baseQuery(ctx: ReportContext): SelectQueryBuilder<ObjectLiteral> {
diff --git a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
index a1f927a77..5f24359a2 100644
--- a/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
+++ b/apps/edr-freight-api/src/modules/train-schedules/entities/train-schedule.entity.ts
@@ -273,6 +273,20 @@ export class TrainSchedule extends BaseEntity {
   @Column({ name: 'wagon_allocation_snapshot', type: 'jsonb', nullable: true })
   wagonAllocationSnapshot?: WagonAllocationSnapshot | null;
 
+  /**
+   * Why this schedule was cancelled — required at cancel time and shown on every
+   * view of the cancelled train. NULL on live schedules and on rows cancelled
+   * before the reason was captured.
+   */
+  @Column({ name: 'cancellation_reason', type: 'varchar', length: 500, nullable: true })
+  cancellationReason?: string | null;
+
+  @Column({ name: 'cancelled_at', type: 'timestamptz', nullable: true })
+  cancelledAt?: Date | null;
+
+  @Column({ name: 'cancelled_by_user_id', type: 'uuid', nullable: true })
+  cancelledByUserId?: string | null;
+
   @OneToMany(() => TrainScheduleBooking, (scheduleBooking) => scheduleBooking.trainSchedule)
   scheduleBookings?: TrainScheduleBooking[];
 }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts
index 9051bb816..8599a96bc 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.spec.ts
@@ -1379,6 +1379,8 @@ describe('BookingBatchService — built-train wagon capacity', () => {
     maxWagons?: number;
     routeStops?: string[];
     yardCountries?: Record<string, string>;
+    maxPullWeightTons?: number;
+    maxTrainLengthMeters?: number;
   }) => {
     const schedule = {
       id: scheduleId,
@@ -1390,8 +1392,11 @@ describe('BookingBatchService — built-train wagon capacity', () => {
       scheduleBookings: [],
       trainSet: {
         locomotive: {
-          maxPullWeightTons: 1,
-          maxTrainLengthMeters: 1,
+          // Roomy on purpose: these cases exercise the SLOT axis, so the pull
+          // budget must not be what closes the train. Weight-bound behaviour
+          // has its own cases below.
+          maxPullWeightTons: opts.maxPullWeightTons ?? 100000,
+          maxTrainLengthMeters: opts.maxTrainLengthMeters ?? 100000,
           overageToleranceTons: 0,
           overageToleranceMeters: 0,
         },
@@ -1459,15 +1464,28 @@ describe('BookingBatchService — built-train wagon capacity', () => {
     await expect(service.isScheduleFull(scheduleId)).resolves.toBe(true);
   });
 
-  it('is NOT full while physical wagons remain, ignoring weight/length limits', async () => {
+  it('is NOT full while physical wagons remain and the loco can still haul them', async () => {
     const { service } = buildService({
       physicalWagons: 3,
       reserved: [reservedBooking('b1'), reservedBooking('b2')],
     });
-    // 1T pull cap would have been exhausted long ago under the old math.
     await expect(service.isScheduleFull(scheduleId)).resolves.toBe(false);
   });
 
+  it('is FULL when the locomotive cannot pull another wagon, though slots are free', async () => {
+    // The consist has a spare slot, but every wagon spends its TARE out of the
+    // same pull limit the cargo needs — so a slot-free train can still be
+    // weight-full. This is what let a 44-wagon booking plan 4065T gross onto a
+    // 3500T train while the board advertised free wagons.
+    const { service } = buildService({
+      physicalWagons: 3,
+      reserved: [reservedBooking('b1'), reservedBooking('b2')],
+      maxPullWeightTons: 1,
+      maxTrainLengthMeters: 1,
+    });
+    await expect(service.isScheduleFull(scheduleId)).resolves.toBe(true);
+  });
+
   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
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
index d787f737d..bf9c0aa5f 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-batch.service.ts
@@ -658,8 +658,36 @@ export class BookingBatchService implements OnModuleInit {
       }
     }
 
-    const linked =
+    let linked =
       await this.trainScheduleBookingsRepository.existsForBooking(bookingId);
+    // A link row can outlive the booking's own pointer (cleared on one path
+    // while the row survives on another). The booking then looks "linked" here,
+    // so the branch below calls tryAutoWagonAllocation(null) and the paid
+    // booking silently never gets wagons — no error, just no allocation.
+    if (linked && !booking.trainScheduleId) {
+      // The link row still names the train it belongs to — restore the pointer
+      // from it rather than dropping the link, so the booking keeps the train
+      // it was placed on and the allocation below has a schedule to run against.
+      const [link] = await this.trainScheduleBookingsRepository.findByBookingIds([
+        bookingId,
+      ]);
+      if (link?.trainScheduleId) {
+        await this.dataSource
+          .getRepository(Booking)
+          .update(bookingId, { trainScheduleId: link.trainScheduleId } as never);
+        booking.trainScheduleId = link.trainScheduleId;
+        this.logger.warn(
+          `[BATCH] ${booking.reference ?? bookingId} was linked to schedule ${link.trainScheduleId} ` +
+            `with no train_schedule_id of its own — pointer restored so it can allocate`,
+        );
+      } else {
+        await this.trainScheduleBookingsRepository.deleteByScheduleAndBooking(
+          link?.trainScheduleId ?? '',
+          bookingId,
+        );
+        linked = false;
+      }
+    }
     // Intercity is allocated MANUALLY: payment secures the ride, staff then
     // place it on whichever same-route train suits (intercity panel). Unpin
     // from the train it reserved against — that train may be the wrong one by
@@ -5376,10 +5404,13 @@ export class BookingBatchService implements OnModuleInit {
    * Dire→Djibouti leaves the Addis→Dire edges untouched.
    *
    * Two capacity regimes, decided by the schedule's train:
-   * - Built train (Train Builder consist with physical wagons): the consist IS
-   *   the capacity. Wagon slots = physical wagon count; weight and length are
-   *   NOT re-checked here — the builder and adjust-consist already enforced the
-   *   locomotive's pull/length limits when the consist was assembled.
+   * - Built train (Train Builder consist with physical wagons): wagon slots =
+   *   physical wagon count, but the locomotive's weight/length budgets STILL
+   *   apply. The builder only proves the EMPTY consist can be pulled; every
+   *   wagon then spends its tare out of the same pull limit the cargo needs, so
+   *   a 54-wagon consist can be slot-free and still weight-full. Treating the
+   *   consist as unlimited tonnage is what let a 44-wagon booking plan 4065T
+   *   gross onto a 3500T train.
    * - No built train (legacy schedules): the locomotive's length-derived slot
    *   count plus its weight/length budgets, as before — yard staff attach the
    *   missing wagons manually before wagon assignment.
@@ -5392,13 +5423,16 @@ export class BookingBatchService implements OnModuleInit {
   ): Promise<CorridorBudget> {
     const physicalWagons = await this.builtTrainWagonCount(schedule);
     if (physicalWagons != null) {
+      // The consist fixes the SLOT count (never the locomotive's length-derived
+      // estimate), but weight and length stay on the locomotive's real budget —
+      // including its overage tolerance, which `fits` may spend on a whole unit.
       limits = {
         base: {
           wagons: physicalWagons,
-          weightTons: Number.POSITIVE_INFINITY,
-          lengthMeters: Number.POSITIVE_INFINITY,
+          weightTons: limits.base.weightTons,
+          lengthMeters: limits.base.lengthMeters,
         },
-        tolerance: { weightTons: 0, lengthMeters: 0 },
+        tolerance: limits.tolerance,
       };
     }
     // Built trains keep the leg-aware multi-edge corridor too: the wagon
@@ -5631,19 +5665,23 @@ export class BookingBatchService implements OnModuleInit {
     const wagonDims = await this.loadWagonDims();
     const physicalWagons = await this.builtTrainWagonCount(schedule);
     let limits: TrainLimits;
+    const locomotive = trainSetLocomotiveLimits(schedule.trainSet);
     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 },
-      };
+      // The consist fixes the slot count, but the locomotive's pull/length
+      // budget still binds: 54 empty slots are worthless once the tare of the
+      // wagons already loaded has spent the pull limit. Without a locomotive
+      // there is nothing to weigh against, so the slot axis is all that is left.
+      limits = locomotive
+        ? await this.capacityLimits(locomotive)
+        : {
+            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);
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/controllers/train-scheduling.controller.ts b/apps/edr-freight-api/src/modules/train-scheduling/controllers/train-scheduling.controller.ts
index fa32b601b..4fc921ccb 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/controllers/train-scheduling.controller.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/controllers/train-scheduling.controller.ts
@@ -32,6 +32,7 @@ import { FREIGHT_PERMS } from "../../../seed/freight-permissions.registry";
 import { AcceptIntercityBookingsDto } from "../dto/accept-intercity-bookings.dto";
 import { StationWorkDto } from "../dto/station-work.dto";
 import { AssignBookingsDto } from "../dto/assign-bookings.dto";
+import { CancelTrainScheduleDto } from "../dto/cancel-train-schedule.dto";
 import { AssignUnassignedBookingDto } from "../dto/assign-unassigned-booking.dto";
 import { SwitchGovernmentBookingDto } from "../dto/switch-government-booking.dto";
 import { CreateContainerTrainScheduleDto } from "../dto/create-container-train-schedule.dto";
@@ -894,6 +895,28 @@ export class TrainSchedulingController {
     return res.send(buffer);
   }
 
+  @Get("schedules/:id/marshalling/stops")
+  @TrainSchedulingView()
+  @ApiOperation({ summary: "Corridor stops with a logged consist change, in order (Marshalling 2, 3, 4…)" })
+  marshallingStops(@Param("id", ParseUUIDPipe) id: string) {
+    return this.trainSchedulingService.marshallingStops(id);
+  }
+
+  @Get("schedules/:id/marshalling/document/:stopIndex")
+  @TrainSchedulingView()
+  @ApiOperation({ summary: "Download the numbered marshalling PDF for one corridor stop" })
+  async marshallingDocumentAt(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Param("stopIndex", ParseIntPipe) stopIndex: number,
+    @Res() res: Response,
+  ) {
+    const { filename, buffer } = await this.trainSchedulingService.marshallingDocumentAt(id, stopIndex);
+    res.setHeader("Content-Type", "application/pdf");
+    res.setHeader("Content-Disposition", `inline; filename="${filename}"`);
+    res.setHeader("Content-Length", buffer.length);
+    return res.send(buffer);
+  }
+
   // ---- batch / booking-window staff actions ----
 
   @Post("schedules/:id/run-batch")
@@ -1184,14 +1207,22 @@ export class TrainSchedulingController {
   @Post("container/schedules/:id/cancel")
   @TrainSchedulingCancel()
   @ApiOperation({ summary: "Cancel container train schedule" })
-  cancelTrainSchedule(@Param("id", ParseUUIDPipe) id: string) {
-    return this.trainSchedulingService.cancelTrainSchedule(id);
+  cancelTrainSchedule(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: CancelTrainScheduleDto,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    return this.trainSchedulingService.cancelTrainSchedule(id, dto, user?.id);
   }
 
   @Post('bulk/schedules/:id/cancel')
   @TrainSchedulingCancel()
   @ApiOperation({ summary: "Cancel bulk train schedule" })
-  cancelBulkTrainSchedule(@Param("id", ParseUUIDPipe) id: string) {
-    return this.trainSchedulingService.cancelTrainSchedule(id);
+  cancelBulkTrainSchedule(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: CancelTrainScheduleDto,
+    @CurrentUser() user: AuthUserPayload,
+  ) {
+    return this.trainSchedulingService.cancelTrainSchedule(id, dto, user?.id);
   }
 }
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dispatch-partial-load-gate.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/dispatch-partial-load-gate.spec.ts
new file mode 100644
index 000000000..ef98e0887
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dispatch-partial-load-gate.spec.ts
@@ -0,0 +1,145 @@
+import { BadRequestException } from '@nestjs/common';
+
+import { TrainSchedulingService } from './services/train-scheduling.service';
+
+/**
+ * Per-wagon loading dispatch gate. A booking half-loaded at the DEPARTURE yard
+ * blocks the train; a booking that boards further down the corridor
+ * (A→B→C→D carrying a B→C load) never does — its wagons are not due until its
+ * own yard, so the SQL is scoped by `b.origin_yard_id = <schedule origin>`.
+ * The scoping lives in the query, so this checks the parameters that carry it
+ * plus the throw/pass decision on the rows it returns.
+ */
+describe('TrainSchedulingService.assertNoPartiallyLoadedBookings', () => {
+  const ORIGIN = 'yard-a';
+  const SET = 'set-1';
+
+  const makeService = (rows: Array<{ reference: string; loaded: string; total: string }>) => {
+    const calls: Array<{ sql: string; params: unknown[] }> = [];
+    const svc = Object.create(TrainSchedulingService.prototype) as {
+      dataSource: { query: (sql: string, params: unknown[]) => Promise<unknown> };
+      assertNoPartiallyLoadedBookings(
+        schedule: unknown,
+        boardingYardId: string,
+        context: { action: string; yardLabel?: string },
+      ): Promise<void>;
+      assertPassedYardsFullyLoaded(
+        schedule: unknown,
+        stations: Array<{ sequenceNo: number; yardId: string; label: string }>,
+        sequenceNo: number,
+      ): Promise<void>;
+    };
+    svc.dataSource = {
+      query: async (sql: string, params: unknown[]) => {
+        calls.push({ sql, params });
+        return rows;
+      },
+    };
+    return { svc, calls };
+  };
+  const schedule = { trainSetId: SET, originStationId: ORIGIN };
+
+  it('scopes the scan to bookings boarding at this departure yard', async () => {
+    const { svc, calls } = makeService([]);
+    await svc.assertNoPartiallyLoadedBookings(schedule, ORIGIN, { action: 'dispatch' });
+    expect(calls).toHaveLength(1);
+    // The origin filter is what keeps a mid-corridor booking from holding the
+    // train — without it, one early-loaded B→C wagon blocks dispatch at A.
+    expect(calls[0].sql).toContain('b.origin_yard_id = $2');
+    expect(calls[0].params).toEqual([SET, ORIGIN]);
+  });
+
+  it('lets the train go when nothing at this yard is half-loaded', async () => {
+    const { svc } = makeService([]);
+    await expect(
+      svc.assertNoPartiallyLoadedBookings(schedule, ORIGIN, { action: 'dispatch' }),
+    ).resolves.toBeUndefined();
+  });
+
+  it('blocks a booking half-loaded at this yard, naming its progress', async () => {
+    const { svc } = makeService([{ reference: 'BK-2026-000220', loaded: '4', total: '5' }]);
+    await expect(
+      svc.assertNoPartiallyLoadedBookings(schedule, ORIGIN, { action: 'dispatch' }),
+    ).rejects.toThrow(/BK-2026-000220 \(4\/5 wagons loaded\)/);
+    await expect(
+      svc.assertNoPartiallyLoadedBookings(schedule, ORIGIN, { action: 'dispatch' }),
+    ).rejects.toBeInstanceOf(BadRequestException);
+  });
+
+  it('skips the scan entirely for a schedule with no train set', async () => {
+    const { svc, calls } = makeService([{ reference: 'X', loaded: '1', total: '2' }]);
+    await expect(
+      svc.assertNoPartiallyLoadedBookings({ trainSetId: null }, ORIGIN, {
+        action: 'dispatch',
+      }),
+    ).resolves.toBeUndefined();
+    expect(calls).toHaveLength(0);
+  });
+});
+
+/**
+ * Mid-corridor twin: logging a checkpoint at station N means the train left
+ * every earlier stop, so each of those yards is checked for its OWN
+ * half-loaded bookings. The origin is excluded (dispatch gated it) and the
+ * yard being arrived at is excluded (its loading has not happened yet).
+ */
+describe('TrainSchedulingService.assertPassedYardsFullyLoaded', () => {
+  const STATIONS = [
+    { sequenceNo: 0, yardId: 'mojo', label: 'Mojo' },
+    { sequenceNo: 1, yardId: 'adama', label: 'Adama' },
+    { sequenceNo: 2, yardId: 'dire', label: 'Dire Dawa' },
+    { sequenceNo: 3, yardId: 'djibouti', label: 'Djibouti' },
+  ];
+
+  const makeService = (rowsByYard: Record<string, Array<Record<string, string>>>) => {
+    const scanned: string[] = [];
+    const svc = Object.create(TrainSchedulingService.prototype) as {
+      dataSource: { query: (sql: string, params: unknown[]) => Promise<unknown> };
+      assertPassedYardsFullyLoaded(
+        schedule: unknown,
+        stations: typeof STATIONS,
+        sequenceNo: number,
+      ): Promise<void>;
+    };
+    svc.dataSource = {
+      query: async (_sql: string, params: unknown[]) => {
+        const yardId = params[1] as string;
+        scanned.push(yardId);
+        return rowsByYard[yardId] ?? [];
+      },
+    };
+    return { svc, scanned };
+  };
+  const schedule = { trainSetId: 'set-1', originStationId: 'mojo' };
+
+  it('checks the stops already departed, never the origin or the yard being reached', async () => {
+    const { svc, scanned } = makeService({});
+    await svc.assertPassedYardsFullyLoaded(schedule, STATIONS, 3);
+    // Mojo is dispatch's job; Djibouti has not been loaded at yet.
+    expect(scanned).toEqual(['adama', 'dire']);
+  });
+
+  it('blocks the checkpoint when a passed yard left a booking half-loaded', async () => {
+    const { svc } = makeService({
+      adama: [{ reference: 'BK-200', loaded: '5', total: '8' }],
+    });
+    await expect(svc.assertPassedYardsFullyLoaded(schedule, STATIONS, 2)).rejects.toThrow(
+      /Adama.*BK-200 \(5\/8 wagons loaded\)/s,
+    );
+  });
+
+  it('names the resolution the operator has: load the rest, or cancel it', async () => {
+    const { svc } = makeService({
+      adama: [{ reference: 'BK-200', loaded: '5', total: '8' }],
+    });
+    await expect(svc.assertPassedYardsFullyLoaded(schedule, STATIONS, 2)).rejects.toThrow(
+      /customer fault: cancellation fee; EDR fault: no fee, rebookable/,
+    );
+  });
+
+  it('scans nothing at the first checkpoint after the origin', async () => {
+    const { svc, scanned } = makeService({});
+    await svc.assertPassedYardsFullyLoaded(schedule, STATIONS, 1);
+    expect(scanned).toEqual([]);
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/dto/cancel-train-schedule.dto.ts b/apps/edr-freight-api/src/modules/train-scheduling/dto/cancel-train-schedule.dto.ts
new file mode 100644
index 000000000..b3e2c7678
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/train-scheduling/dto/cancel-train-schedule.dto.ts
@@ -0,0 +1,14 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, IsString, MaxLength } from 'class-validator';
+
+export class CancelTrainScheduleDto {
+  @ApiProperty({
+    description:
+      'Why this train is being cancelled. Shown on the schedule from then on, and to the staff who have to re-place its bookings.',
+    maxLength: 500,
+  })
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(500)
+  reason!: string;
+}
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
index 4e2724f49..9dc75335f 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/intercity.service.ts
@@ -7,6 +7,7 @@ import {
 import { InjectDataSource } from '@nestjs/typeorm';
 import { DataSource } from 'typeorm';
 
+import { bookingTonsSql } from '../bookings/booking-tons.sql';
 import { Booking } from '../bookings/entities/booking.entity';
 import { RouteMilestone } from '../routes/entities/route-milestone.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
@@ -58,7 +59,7 @@ export class IntercityService {
               b.reference                 AS "reference",
               b.status                    AS "status",
               b.freight_type              AS "freightType",
-              b.cargo_total_weight_vgm    AS "weightTons",
+              ${bookingTonsSql('b')} AS "weightTons",
               b.loaded_at                 AS "loadedAt",
               b.arrived_at                AS "arrivedAt",
               company.name                AS "customer",
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.ts
index 85b6d0878..e95cb4fe8 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/remainder-placement.service.ts
@@ -333,7 +333,9 @@ export class RemainderPlacementService {
 
     return deferred.map((u) => ({
       containerNumber: u.containerNumber,
-      sealNumber: u.sealNumber ?? undefined,
+      // Deferred units predate the seal requirement; the booking service
+      // normalizes the blank back to null rather than rejecting the re-book.
+      sealNumber: u.sealNumber ?? '',
       vgmTons: Number(u.vgmTons),
       isHazardous: u.isHazardous,
       isReefer: u.isReefer,
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/services/train-scheduling.service.spec.ts b/apps/edr-freight-api/src/modules/train-scheduling/services/train-scheduling.service.spec.ts
index 2b8971e81..d6e778216 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/services/train-scheduling.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/services/train-scheduling.service.spec.ts
@@ -1209,7 +1209,7 @@ describe('TrainSchedulingService', () => {
       expect(html).toContain('<span>To load en route</span><strong>1 containers</strong>');
     });
 
-    it('prints coupled/switched wagons logged at this stop, and omits the box when there are none', () => {
+    it('prints the consist-changes table for this stop, and omits it when there are none', () => {
       const schedule = {
         id: 'schedule-1',
         trainNumber: '8302',
@@ -1223,16 +1223,21 @@ describe('TrainSchedulingService', () => {
 
       const withChanges = build(schedule, {
         consistChangesAtStop: [
-          { action: 'ADD', wagonNumber: 'W-1002' },
-          { action: 'SWITCH', wagonNumber: 'W-0501 → W-1003' },
+          { wagonNumber: 'W-1002', event: 'Coupled', containerNumbers: 'EMPTY WAGON' },
+          { wagonNumber: 'W-1005', event: 'Coupled', containerNumbers: 'CONT-004, CONT-005' },
+          { wagonNumber: 'W-0501 → W-1003', event: 'Switched', containerNumbers: 'CONT-011' },
         ],
       });
-      expect(withChanges).toContain('Consist changed at this stop');
-      expect(withChanges).toContain('Coupled: W-1002');
-      expect(withChanges).toContain('Uncoupled — replaced: W-0501 → W-1003');
+      expect(withChanges).toContain('Consist Changed At This Stop');
+      expect(withChanges).toContain('<td>W-1002</td>');
+      expect(withChanges).toContain('<td>Coupled</td>');
+      expect(withChanges).toContain('<td>EMPTY WAGON</td>');
+      expect(withChanges).toContain('<td>CONT-004, CONT-005</td>');
+      expect(withChanges).toContain('<td>W-0501 → W-1003</td>');
+      expect(withChanges).toContain('<td>Switched</td>');
 
       const withoutChanges = build(schedule, {});
-      expect(withoutChanges).not.toContain('Consist changed at this stop');
+      expect(withoutChanges).not.toContain('Consist Changed At This Stop');
     });
 
     it('lists loaded empty containers by number and states they are empty', () => {
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/services/train-scheduling.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/services/train-scheduling.service.ts
index 858d14c90..dbf0c7f7c 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/services/train-scheduling.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/services/train-scheduling.service.ts
@@ -2949,7 +2949,9 @@ export class TrainSchedulingService {
     // Per-wagon loading: a booking mid-load is neither ridable nor removable —
     // every wagon must be LOADED, or the never-loaded remainder cancelled
     // (at-loading cancellation), before the train departs.
-    await this.assertNoPartiallyLoadedBookings(schedule);
+    await this.assertNoPartiallyLoadedBookings(schedule, schedule.originStationId, {
+      action: 'dispatch',
+    });
 
     await this.dataSource.transaction(async (manager) => {
       const trainNumber = await this.assignTrainNumber(manager, schedule);
@@ -3149,13 +3151,21 @@ export class TrainSchedulingService {
    * (their charge sits on the credit ledger) yet ride from accept.
    */
   /**
-   * Per-wagon loading dispatch gate: a booking with SOME wagons LOADED and
-   * SOME still PLANNED/RESERVED must resolve before departure — load the rest
-   * or cancel it (which shrinks the booking to its loaded wagons). Blocking
-   * here beats silently unassigning: unassign would delete LOADED allocations
-   * and strand cargo that is physically on the train.
+   * Per-wagon loading gate: a booking with SOME wagons LOADED and SOME still
+   * PLANNED/RESERVED must resolve before the train leaves the yard it boards
+   * at — load the rest, or cancel the remainder (which shrinks the booking to
+   * its loaded wagons). Blocking beats silently unassigning: unassign would
+   * delete LOADED allocations and strand cargo physically on the train.
+   *
+   * Scoped to bookings BOARDING AT `boardingYardId`, so each yard answers only
+   * for its own cargo: a mid-corridor booking (A→B→C→D carrying a B→C load) is
+   * not due at A and must never hold the train there.
    */
-  private async assertNoPartiallyLoadedBookings(schedule: TrainSchedule): Promise<void> {
+  private async assertNoPartiallyLoadedBookings(
+    schedule: TrainSchedule,
+    boardingYardId: string,
+    context: { action: string; yardLabel?: string },
+  ): Promise<void> {
     if (!schedule.trainSetId) return;
     const rows: Array<{ reference: string; loaded: string; total: string }> =
       await this.dataSource.query(
@@ -3166,24 +3176,51 @@ export class TrainSchedulingService {
            JOIN freight.train_set_wagons tsw ON tsw.id = a.train_set_wagon_id
            JOIN freight.bookings b ON b.id = a.booking_id
           WHERE tsw.train_set_id = $1
+            AND b.origin_yard_id = $2
             AND a.deleted_at IS NULL
             AND tsw.deleted_at IS NULL
             AND b.deleted_at IS NULL
           GROUP BY b.id, b.reference
          HAVING COUNT(*) FILTER (WHERE a.status IN ('LOADED', 'DEPARTED')) > 0
             AND COUNT(*) FILTER (WHERE a.status NOT IN ('LOADED', 'DEPARTED')) > 0`,
-        [schedule.trainSetId],
+        [schedule.trainSetId, boardingYardId],
       );
     if (rows.length) {
       const detail = rows
         .map((r) => `${r.reference} (${r.loaded}/${r.total} wagons loaded)`)
         .join(', ');
+      const where = context.yardLabel ? ` at ${context.yardLabel}` : '';
       throw new BadRequestException(
-        `Cannot dispatch: booking(s) partially loaded — load every wagon or cancel the remainder first: ${detail}`,
+        `Cannot ${context.action}: booking(s) partially loaded${where} — load every wagon ` +
+          `or cancel the remainder (customer fault: cancellation fee; EDR fault: no fee, ` +
+          `rebookable) first: ${detail}`,
       );
     }
   }
 
+  /**
+   * Mid-corridor twin of the dispatch gate. Logging a checkpoint at station N
+   * asserts the train has left every earlier stop, so each of those yards must
+   * have no half-loaded booking of its own left behind. The origin (seq 0) is
+   * skipped — dispatch already gated it — and the final station is included:
+   * arriving there still means the train left the stop before it.
+   */
+  private async assertPassedYardsFullyLoaded(
+    schedule: TrainSchedule,
+    stations: Array<{ sequenceNo: number; yardId: string; label: string }>,
+    sequenceNo: number,
+  ): Promise<void> {
+    const departed = stations.filter(
+      (st) => st.sequenceNo > 0 && st.sequenceNo < sequenceNo,
+    );
+    for (const st of departed) {
+      await this.assertNoPartiallyLoadedBookings(schedule, st.yardId, {
+        action: 'record this checkpoint',
+        yardLabel: st.label,
+      });
+    }
+  }
+
   private async unloadedOriginBoarderIds(
     scheduleId: string,
     originYardId: string,
@@ -3580,7 +3617,83 @@ export class TrainSchedulingService {
     return { wagons, unassignedBookings };
   }
 
-  async intercityMarshallingDocument(scheduleId: string): Promise<{ filename: string; buffer: Buffer }> {
+  /**
+   * Every corridor stop where the consist actually changed for this schedule
+   * (coupled, uncoupled, or switched — any flavor), in the order the train
+   * reached them. Origin is never in this list — it's always its own doc (the
+   * plain import/export load list), so numbering here starts at 2. A stop with
+   * only a routine checkpoint and no consist change never gets a row, which is
+   * the point: "Marshalling 2, 3, 4…" tracks events, not raw stop count.
+   */
+  async marshallingStops(
+    scheduleId: string,
+  ): Promise<Array<{ stopIndex: number; yardId: string; yardLabel: string; firstOccurredAt: string }>> {
+    const rows = await this.dataSource.getRepository(ScheduleWagonAdjustmentLog).find({
+      where: { trainScheduleId: scheduleId },
+      order: { occurredAt: 'ASC' },
+    });
+    const firstSeenAt = new Map<string, Date>();
+    for (const row of rows) {
+      if (!row.yardId || firstSeenAt.has(row.yardId)) continue;
+      firstSeenAt.set(row.yardId, row.occurredAt);
+    }
+    const orderedYardIds = [...firstSeenAt.entries()]
+      .sort((a, b) => a[1].getTime() - b[1].getTime())
+      .map(([yardId]) => yardId);
+    const labels = await this.yardLabelsById(orderedYardIds);
+    return orderedYardIds.map((yardId, i) => ({
+      stopIndex: i + 2,
+      yardId,
+      yardLabel: labels.get(yardId) ?? yardId,
+      firstOccurredAt: firstSeenAt.get(yardId)!.toISOString(),
+    }));
+  }
+
+  /**
+   * The coupled/uncoupled/switched rows for one stop, in the locked table
+   * shape (wagon, event, containers). "EMPTY WAGON" replaces the container
+   * list rather than a blank cell — the column always exists so a loaded and
+   * an empty coupling read as the same table, not two different layouts.
+   * Cargo for ADD/REMOVE rows is read off the schedule's OWN slot allocations
+   * for that physical wagon: an ADD is a leg slot boarding already loaded (see
+   * stampSlotLegs) or an empty couple (plannedWagonCouples) with none; a
+   * REMOVE is a slot alighting with its cargo, or an empty trim. A SWITCH row
+   * carries the incoming wagon's id — the slot's cargo already rides it.
+   */
+  private consistChangesAt(
+    schedule: TrainSchedule,
+    logRows: ScheduleWagonAdjustmentLog[],
+  ): Array<{ wagonNumber: string; event: 'Coupled' | 'Uncoupled' | 'Switched'; containerNumbers: string }> {
+    const slotByPhysicalWagonId = new Map(
+      (schedule.trainSet?.wagons ?? [])
+        .filter((wagon) => wagon.physicalWagonId)
+        .map((wagon) => [wagon.physicalWagonId as string, wagon]),
+    );
+    return logRows.map((row) => {
+      const slot = slotByPhysicalWagonId.get(row.wagonId);
+      const containerNumbers = (slot?.allocations ?? [])
+        .flatMap((allocation) => allocation.containerItems ?? [])
+        .map((item) => item.containerNumber)
+        .filter(Boolean)
+        .join(', ');
+      return {
+        wagonNumber: row.wagonNumber,
+        event: row.action === 'ADD' ? 'Coupled' : row.action === 'REMOVE' ? 'Uncoupled' : 'Switched',
+        containerNumbers: containerNumbers || 'EMPTY WAGON',
+      };
+    });
+  }
+
+  /**
+   * The numbered marshalling document for one corridor stop (see
+   * marshallingStops — stopIndex 2+, origin is its own separate doc).
+   * ponytail: the wagon table always shows the CURRENT on-board state, not a
+   * point-in-time reconstruction of what stood on the train at that past
+   * stop — a full historical snapshot is a much bigger feature nobody has
+   * asked for. What's stop-specific is the consist-changes table below it,
+   * which IS scoped to that stop's own logged events.
+   */
+  async marshallingDocumentAt(scheduleId: string, stopIndex: number): Promise<{ filename: string; buffer: Buffer }> {
     const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
     if (!schedule) {
       throw new NotFoundException(`Train schedule ${scheduleId} not found`);
@@ -3590,24 +3703,66 @@ export class TrainSchedulingService {
         'Intercity marshalling document applies only to dispatched or arrived trains',
       );
     }
+    const stops = await this.marshallingStops(scheduleId);
+    const stop = stops.find((s) => s.stopIndex === stopIndex);
+    if (!stop) {
+      throw new NotFoundException(
+        `No marshalling document at stop ${stopIndex} for this schedule — nothing coupled/uncoupled there, or the stop doesn't exist`,
+      );
+    }
 
+    const { wagons, unassignedBookings } = this.intercityOnBoardView(schedule);
+    const logRows = await this.dataSource.getRepository(ScheduleWagonAdjustmentLog).find({
+      where: { trainScheduleId: scheduleId, yardId: stop.yardId },
+      order: { occurredAt: 'ASC' },
+    });
+    const html = this.buildExportLoadListHtml(schedule, {
+      title: `Intercity Marshalling Document / Load List (Marshalling ${stopIndex})`,
+      positionLabel: `At ${stop.yardLabel}`,
+      wagons,
+      unassignedBookings,
+      emptyContainers: await this.loadedEmptyContainers(scheduleId),
+      logoImageUrl: await this.logoSettings.getLogoImageUrl(),
+      consistChangesAtStop: this.consistChangesAt(schedule, logRows),
+    });
+    // Styled table-aware fallback (marshalling grid) — see importLoadListDocument.
+    const buffer = await this.pdfDocuments.renderTabularDocument(html, `Marshalling ${stopIndex}`);
+    const reference = schedule.trainNumber ?? schedule.id;
+    return {
+      filename: `marshalling-${stopIndex}-${this.safeDocumentName(reference)}.pdf`,
+      buffer,
+    };
+  }
+
+  /**
+   * Back-compat alias: the single "current" intercity doc (Marshalling 2) the
+   * old one-document-per-schedule UI calls. Resolves to the LATEST stop with
+   * a logged consist change; falls back to the current-position doc with no
+   * changes table when nothing has coupled/uncoupled yet (e.g. right after
+   * dispatch, before any mid-corridor stop).
+   */
+  async intercityMarshallingDocument(scheduleId: string): Promise<{ filename: string; buffer: Buffer }> {
+    const stops = await this.marshallingStops(scheduleId);
+    const latest = stops[stops.length - 1];
+    if (latest) {
+      return this.marshallingDocumentAt(scheduleId, latest.stopIndex);
+    }
+
+    const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(scheduleId);
+    if (!schedule) {
+      throw new NotFoundException(`Train schedule ${scheduleId} not found`);
+    }
+    if (schedule.status !== 'DISPATCHED' && schedule.status !== 'ARRIVED') {
+      throw new BadRequestException(
+        'Intercity marshalling document applies only to dispatched or arrived trains',
+      );
+    }
     const checkpoints = await this.trainCheckpointEventsRepository.findBySchedule(scheduleId);
     const last = checkpoints[checkpoints.length - 1];
     const positionLabel = last
       ? `After ${last.yard?.label ?? last.yard?.code ?? 'checkpoint'}`
       : `At ${schedule.originStation?.label ?? schedule.originStation?.code ?? 'origin'} — no checkpoint recorded`;
-
     const { wagons, unassignedBookings } = this.intercityOnBoardView(schedule);
-    // Couples/switches logged AT THIS STOP — what staff standing here actually
-    // just did to the consist. Bare trims (REMOVE, no replacement) are left
-    // out: nothing new to point staff at for those. Origin adjustments (a
-    // different yard) don't show up on this stop's document.
-    const consistChangesAtStop = last
-      ? await this.dataSource.getRepository(ScheduleWagonAdjustmentLog).find({
-          where: { trainScheduleId: scheduleId, yardId: last.yardId, action: In(['ADD', 'SWITCH']) },
-          order: { occurredAt: 'DESC' },
-        })
-      : [];
     const html = this.buildExportLoadListHtml(schedule, {
       title: 'Intercity Marshalling Document / Load List (Marshalling 2)',
       positionLabel,
@@ -3615,7 +3770,6 @@ export class TrainSchedulingService {
       unassignedBookings,
       emptyContainers: await this.loadedEmptyContainers(scheduleId),
       logoImageUrl: await this.logoSettings.getLogoImageUrl(),
-      consistChangesAtStop,
     });
     // Styled table-aware fallback (marshalling grid) — see importLoadListDocument.
     const buffer = await this.pdfDocuments.renderTabularDocument(html, 'Intercity marshalling / load list');
@@ -3685,10 +3839,14 @@ export class TrainSchedulingService {
       // Slots that couple to the train downstream (slot id → board yard label).
       // Their cargo renders as TO LOAD AT and stays out of the loaded tallies.
       pendingBoardYardLabelBySlot?: Map<string, string>;
-      // Intercity (Marshalling 2) only: couples/switches logged at the stop
-      // this document is printed at (see ScheduleWagonAdjustmentLog). Origin
-      // import/export docs never pass this, so they render no such box.
-      consistChangesAtStop?: ScheduleWagonAdjustmentLog[];
+      // Numbered marshalling docs only (see marshallingDocumentAt /
+      // consistChangesAt) — couples/uncouples/switches logged at THIS stop.
+      // Origin import/export docs never pass this, so they render no such box.
+      consistChangesAtStop?: Array<{
+        wagonNumber: string;
+        event: 'Coupled' | 'Uncoupled' | 'Switched';
+        containerNumbers: string;
+      }>;
     },
   ): string {
     const esc = (value: unknown) =>
@@ -3853,6 +4011,7 @@ export class TrainSchedulingService {
     .tile span { display: block; color: #64748b; font-size: 9px; text-transform: uppercase; letter-spacing: .05em; margin-bottom: 4px; }
     .tile strong { font-size: 11px; }
     ${logoImageCss()}
+    h2 { margin: 16px 0 6px; font-size: 12px; color: #0f766e; text-transform: uppercase; letter-spacing: .05em; }
     table { width: 100%; border-collapse: collapse; }
     th { background: #f8fafc; color: #475569; text-align: left; }
     th, td { border: 1px solid #cbd5e1; padding: 5px 6px; font-size: 9.5px; vertical-align: top; }
@@ -3901,19 +4060,27 @@ export class TrainSchedulingService {
 
   ${
     opts?.consistChangesAtStop?.length
-      ? `<div class="notice">
-    <b>Consist changed at this stop:</b>
-    ${(() => {
-      const coupled = opts.consistChangesAtStop.filter((row) => row.action === 'ADD');
-      const switched = opts.consistChangesAtStop.filter((row) => row.action === 'SWITCH');
-      return [
-        coupled.length ? `Coupled: ${esc(coupled.map((row) => row.wagonNumber).join(', '))}` : '',
-        switched.length ? `Uncoupled — replaced: ${esc(switched.map((row) => row.wagonNumber).join(', '))}` : '',
-      ]
-        .filter(Boolean)
-        .join(' &nbsp;|&nbsp; ');
-    })()}
-  </div>`
+      ? `<h2>Consist Changed At This Stop</h2>
+  <table>
+    <thead>
+      <tr>
+        <th>Wagon No</th>
+        <th>Event</th>
+        <th>Container No</th>
+      </tr>
+    </thead>
+    <tbody>
+      ${opts.consistChangesAtStop
+        .map(
+          (row) => `<tr>
+        <td>${esc(row.wagonNumber)}</td>
+        <td>${esc(row.event)}</td>
+        <td>${esc(row.containerNumbers)}</td>
+      </tr>`,
+        )
+        .join('')}
+    </tbody>
+  </table>`
       : ''
   }
 
@@ -4744,6 +4911,12 @@ export class TrainSchedulingService {
           : TrainCheckpointKind.Passed);
     const occurredAt = dto.occurredAt ? new Date(dto.occurredAt) : new Date();
     await this.assertCheckpointTime(schedule, stations, dto.sequenceNo, occurredAt);
+    // Per-wagon loading, mid-corridor: recording THIS station means the train
+    // left the previous one, so every booking that boarded back there must be
+    // fully loaded or its remainder cancelled. The origin is covered by
+    // dispatch; here we answer for the stops between it and this one, so a
+    // skipped checkpoint log cannot smuggle an unresolved yard past the gate.
+    await this.assertPassedYardsFullyLoaded(schedule, stations, dto.sequenceNo);
 
     // Upsert by (scheduleId, sequenceNo) so re-logging a station updates rather than duplicates.
     const [existing] = await this.trainCheckpointEventsRepository.findAll({
@@ -4964,6 +5137,76 @@ export class TrainSchedulingService {
             await manager.getRepository(ScheduleWagonAdjustmentLog).save(coupleLogRows);
           }
         }
+
+        // Leg slots (booking legs boarding/alighting mid-corridor — see
+        // stampSlotLegs) reaching their board/alight yard here: logged same as
+        // planned couples/cuts above, so the marshalling document can show
+        // what coupled ALREADY LOADED / uncoupled WITH cargo at this stop.
+        // Purely observational — their physical wagon was already pinned to
+        // the slot at schedule-build time (assignPhysicalWagonsToSlots), so
+        // nothing here changes wagon state, only the log. Dedupe against
+        // existing rows (not a wagon-state flag, unlike the couple/cut blocks
+        // above) since passedYardIds re-includes earlier stops on every call.
+        const legSlotsHere = (schedule.trainSet?.wagons ?? []).filter(
+          (slot) =>
+            slot.physicalWagonId &&
+            ((slot.boardYardId && passedYardIds.includes(slot.boardYardId)) ||
+              (slot.alightYardId && passedYardIds.includes(slot.alightYardId))),
+        );
+        if (legSlotsHere.length && builtTrainId) {
+          const legWagonIds = [
+            ...new Set(legSlotsHere.map((slot) => slot.physicalWagonId!)),
+          ];
+          const legWagonById = new Map(
+            (
+              await manager.getRepository(Wagon).find({ where: { id: In(legWagonIds) } })
+            ).map((w) => [w.id, w]),
+          );
+          const alreadyLogged = new Set(
+            (
+              await manager.getRepository(ScheduleWagonAdjustmentLog).find({
+                where: {
+                  trainScheduleId: scheduleId,
+                  wagonId: In(legWagonIds),
+                  action: In(['ADD', 'REMOVE']),
+                },
+              })
+            ).map((row) => `${row.wagonId}:${row.action}:${row.yardId}`),
+          );
+          const legLogRows: ScheduleWagonAdjustmentLog[] = [];
+          for (const slot of legSlotsHere) {
+            const wagon = legWagonById.get(slot.physicalWagonId!);
+            if (!wagon) continue;
+            const events: Array<{ action: 'ADD' | 'REMOVE'; yardId: string }> = [];
+            if (slot.boardYardId && passedYardIds.includes(slot.boardYardId)) {
+              events.push({ action: 'ADD', yardId: slot.boardYardId });
+            }
+            if (slot.alightYardId && passedYardIds.includes(slot.alightYardId)) {
+              events.push({ action: 'REMOVE', yardId: slot.alightYardId });
+            }
+            for (const { action, yardId } of events) {
+              const key = `${wagon.id}:${action}:${yardId}`;
+              if (alreadyLogged.has(key)) continue;
+              alreadyLogged.add(key);
+              legLogRows.push(
+                manager.getRepository(ScheduleWagonAdjustmentLog).create({
+                  trainScheduleId: scheduleId,
+                  trainId: builtTrainId,
+                  action,
+                  wagonId: wagon.id,
+                  wagonNumber: wagon.wagonNumber,
+                  adjustedByUserId: null,
+                  yardId,
+                  occurredAt,
+                }),
+              );
+            }
+          }
+          if (legLogRows.length) {
+            await manager.getRepository(ScheduleWagonAdjustmentLog).save(legLogRows);
+          }
+        }
+
         await manager
           .getRepository(Wagon)
           .createQueryBuilder()
@@ -5496,7 +5739,11 @@ export class TrainSchedulingService {
     return this.getTrainScheduleById(id);
   }
 
-  async cancelTrainSchedule(id: string) {
+  async cancelTrainSchedule(
+    id: string,
+    dto?: { reason?: string },
+    userId?: string,
+  ) {
     const schedule = await this.trainSchedulesRepository.findByIdWithFullGraph(id);
     if (!schedule) {
       throw new NotFoundException(`Train schedule ${id} not found`);
@@ -5527,6 +5774,11 @@ export class TrainSchedulingService {
             TrainScheduleStatusEnum.Cancelled,
             now,
           ),
+          // Why the train died — read back by every view of the cancelled
+          // schedule, and by the staff who have to re-place its bookings.
+          cancellationReason: dto?.reason?.trim() || null,
+          cancelledAt: now,
+          cancelledByUserId: userId ?? null,
         },
         manager,
       );
@@ -8020,6 +8272,8 @@ export class TrainSchedulingService {
       freightType: this.resolveScheduleFreightType(schedule),
       status: schedule.status,
       bookingWindowStatus: schedule.bookingWindowStatus ?? 'OPEN',
+      cancellationReason: schedule.cancellationReason ?? null,
+      cancelledAt: schedule.cancelledAt ?? null,
       maxWagons: schedule.maxWagons ?? 0,
       remainingWagons: Math.max(
         0,
@@ -9978,6 +10232,8 @@ export class TrainSchedulingService {
       id: schedule.id,
       reference: schedule.reference ?? null,
       status: schedule.status,
+      cancellationReason: schedule.cancellationReason ?? null,
+      cancelledAt: schedule.cancelledAt ?? null,
       freightType: this.resolveScheduleFreightType(schedule),
       trainNumber: schedule.trainNumber ?? null,
       voyageNumber: schedule.voyageNumber ?? null,
diff --git a/apps/edr-freight-api/src/modules/warehouses/container-stack-placement.spec.ts b/apps/edr-freight-api/src/modules/warehouses/container-stack-placement.spec.ts
new file mode 100644
index 000000000..6a9d2ccde
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/container-stack-placement.spec.ts
@@ -0,0 +1,222 @@
+import { BadRequestException, ConflictException } from '@nestjs/common';
+
+import { WarehousePlacementService } from './warehouse-placement.service';
+import { WarehouseZoneStacksService } from './warehouse-zone-stacks.service';
+
+/**
+ * The physical rules a yard operator would recognise: nothing floats above an
+ * empty level, a slot holds one box, and the ids a client sends are only
+ * believed after the whole chain has been resolved server-side.
+ */
+
+const CHAIN = {
+  slotId: 'slot-2',
+  slotStatus: 'AVAILABLE',
+  slotIsActive: true,
+  level: 2,
+  stackId: 'stack-1',
+  stackCode: 'ZA-001',
+  stackStatus: 'ACTIVE',
+  stackIsActive: true,
+  maxStackHeight: 3,
+  zoneId: 'zone-1',
+  zoneCode: 'L1-O-A-ZA',
+  zoneType: 'CONTAINER_ZONE',
+  zoneStatus: 'ACTIVE',
+  zoneIsActive: true,
+  yardId: 'yard-1',
+  yardCode: 'L1-O-A',
+  yardType: 'CONTAINER_YARD',
+  yardDirection: null,
+  yardStatus: 'ACTIVE',
+  yardIsActive: true,
+  warehouseId: 'wh-1',
+  warehouseCode: 'L1-OPEN',
+  warehouseStatus: 'ACTIVE',
+  warehouseIsActive: true,
+};
+
+/** A placement service whose slot chain and stack occupancy are dictated by the test. */
+function makePlacement(chain: Partial<typeof CHAIN>, occupiedLevels: number[], slotTakenBy: string | null = null) {
+  const service = Object.create(WarehousePlacementService.prototype) as Record<string, unknown>;
+  service.resolveSlot = jest.fn().mockResolvedValue({ ...CHAIN, ...chain });
+  service.occupiedLevels = jest.fn().mockResolvedValue(occupiedLevels);
+  service.em = () => ({ query: jest.fn().mockResolvedValue(slotTakenBy ? [{ id: slotTakenBy }] : []) });
+  return service as unknown as WarehousePlacementService;
+}
+
+const placementInput = {
+  slotId: 'slot-2',
+  warehouseId: 'wh-1',
+  yardId: 'yard-1',
+  zoneId: 'zone-1',
+  quantity: 1,
+};
+
+describe('WarehousePlacementService.assertStackable', () => {
+  const service = Object.create(WarehousePlacementService.prototype) as WarehousePlacementService;
+
+  it('always allows the ground level', () => {
+    expect(() => service.assertStackable({ level: 1, stackCode: 'ZA-001' }, [])).not.toThrow();
+  });
+
+  it('allows level 2 once level 1 is filled', () => {
+    expect(() => service.assertStackable({ level: 2, stackCode: 'ZA-001' }, [1])).not.toThrow();
+  });
+
+  it('allows level 3 once levels 1 and 2 are filled', () => {
+    expect(() => service.assertStackable({ level: 3, stackCode: 'ZA-001' }, [1, 2])).not.toThrow();
+  });
+
+  it('refuses level 2 over an empty ground level', () => {
+    expect(() => service.assertStackable({ level: 2, stackCode: 'ZA-001' }, [])).toThrow(
+      /level 2 cannot be filled while level\(s\) 1 are empty/,
+    );
+  });
+
+  it('refuses level 3 when level 2 is empty', () => {
+    expect(() => service.assertStackable({ level: 3, stackCode: 'ZA-001' }, [1])).toThrow(
+      /level\(s\) 2 are empty/,
+    );
+  });
+});
+
+describe('WarehousePlacementService.validateSlotForInventory', () => {
+  it('accepts a consistent hierarchy with the level below filled', async () => {
+    const service = makePlacement({}, [1]);
+    await expect(service.validateSlotForInventory(placementInput)).resolves.toMatchObject({
+      stackId: 'stack-1',
+      level: 2,
+    });
+  });
+
+  it('refuses a slot belonging to another zone', async () => {
+    const service = makePlacement({ zoneId: 'other-zone' }, [1]);
+    await expect(service.validateSlotForInventory(placementInput)).rejects.toBeInstanceOf(BadRequestException);
+  });
+
+  it('refuses a zone whose yard is not the one given', async () => {
+    const service = makePlacement({ yardId: 'other-yard' }, [1]);
+    await expect(service.validateSlotForInventory(placementInput)).rejects.toThrow(/does not belong|not the yard given/);
+  });
+
+  it('refuses a yard whose warehouse is not the one given', async () => {
+    const service = makePlacement({ warehouseId: 'other-wh' }, [1]);
+    await expect(service.validateSlotForInventory(placementInput)).rejects.toThrow(/not the warehouse given/);
+  });
+
+  it('refuses an inactive stack', async () => {
+    const service = makePlacement({ stackStatus: 'INACTIVE', stackIsActive: false }, [1]);
+    await expect(service.validateSlotForInventory(placementInput)).rejects.toThrow(/Stack ZA-001 is not active/);
+  });
+
+  it('refuses a blocked slot', async () => {
+    const service = makePlacement({ slotStatus: 'BLOCKED' }, [1]);
+    await expect(service.validateSlotForInventory(placementInput)).rejects.toThrow(/is BLOCKED/);
+  });
+
+  it('accepts a slot reserved for the box now arriving', async () => {
+    const service = makePlacement({ slotStatus: 'RESERVED' }, [1]);
+    await expect(service.validateSlotForInventory(placementInput)).resolves.toMatchObject({ level: 2 });
+  });
+
+  it('refuses a slot another container already stands in', async () => {
+    const service = makePlacement({}, [1], 'other-inventory');
+    await expect(service.validateSlotForInventory(placementInput)).rejects.toBeInstanceOf(ConflictException);
+  });
+
+  it('refuses a level above the stack height', async () => {
+    const service = makePlacement({ level: 4, slotId: 'slot-4' }, [1, 2, 3]);
+    await expect(
+      service.validateSlotForInventory({ ...placementInput, slotId: 'slot-4' }),
+    ).rejects.toThrow(/above stack ZA-001's maximum height of 3/);
+  });
+
+  it('refuses a row that still covers several containers', async () => {
+    const service = makePlacement({}, [1]);
+    await expect(service.validateSlotForInventory({ ...placementInput, quantity: 5 })).rejects.toThrow(
+      /covers 5 containers/,
+    );
+  });
+
+  it('skips container stacking rules for a bulk yard', async () => {
+    // Level 2 over an empty level 1 would be refused in a container yard;
+    // a bulk yard has no vertical semantics to enforce.
+    const service = makePlacement({ yardType: 'BULK_YARD' }, []);
+    await expect(service.validateSlotForInventory({ ...placementInput, quantity: 12 })).resolves.toMatchObject({
+      yardType: 'BULK_YARD',
+    });
+  });
+});
+
+describe('WarehousePlacementService.getContainerAccessibility', () => {
+  function makeAccessibility(placed: unknown, blocking: unknown[]) {
+    const service = Object.create(WarehousePlacementService.prototype) as Record<string, unknown>;
+    const query = jest
+      .fn()
+      .mockResolvedValueOnce(placed ? [placed] : [])
+      .mockResolvedValueOnce(blocking);
+    service.em = () => ({ query });
+    return service as unknown as WarehousePlacementService;
+  }
+
+  it('reports a ground container buried under two others', async () => {
+    const service = makeAccessibility(
+      { inventoryId: 'inv-1', level: 1, stackId: 'stack-1', stackCode: 'ZA-001' },
+      [
+        { inventoryId: 'inv-3', level: 3, status: 'STORED', containerNumber: 'CONT-003' },
+        { inventoryId: 'inv-2', level: 2, status: 'STORED', containerNumber: 'CONT-002' },
+      ],
+    );
+
+    await expect(service.getContainerAccessibility('inv-1')).resolves.toEqual({
+      accessible: false,
+      inventoryId: 'inv-1',
+      stackCode: 'ZA-001',
+      level: 1,
+      blockingContainers: [
+        { inventoryId: 'inv-3', level: 3, status: 'STORED', containerNumber: 'CONT-003' },
+        { inventoryId: 'inv-2', level: 2, status: 'STORED', containerNumber: 'CONT-002' },
+      ],
+    });
+  });
+
+  it('reports the top container as reachable', async () => {
+    const service = makeAccessibility({ inventoryId: 'inv-3', level: 3, stackId: 'stack-1', stackCode: 'ZA-001' }, []);
+    await expect(service.getContainerAccessibility('inv-3')).resolves.toMatchObject({ accessible: true });
+  });
+
+  it('treats an item with no slot as reachable', async () => {
+    const service = makeAccessibility({ inventoryId: 'inv-9', level: null, stackId: null, stackCode: null }, []);
+    await expect(service.getContainerAccessibility('inv-9')).resolves.toEqual({
+      accessible: true,
+      inventoryId: 'inv-9',
+      stackCode: null,
+      level: null,
+      blockingContainers: [],
+    });
+  });
+});
+
+describe('WarehouseZoneStacksService guards', () => {
+  function makeStacksService(occupied: number[]) {
+    const service = Object.create(WarehouseZoneStacksService.prototype) as Record<string, unknown>;
+    service.placement = { occupiedLevels: jest.fn().mockResolvedValue(occupied) };
+    service.stacksRepository = {
+      findById: jest.fn().mockResolvedValue({ id: 'stack-1', code: 'ZA-001', zoneId: 'zone-1', slots: [] }),
+    };
+    service.dataSource = { transaction: jest.fn() };
+    return service as unknown as WarehouseZoneStacksService;
+  }
+
+  it('refuses to delete a stack that still holds containers', async () => {
+    await expect(makeStacksService([1, 2]).remove('stack-1')).rejects.toThrow(
+      /still holds 2 container\(s\) at level\(s\) 1, 2/,
+    );
+  });
+
+  it('deletes an empty stack', async () => {
+    const service = makeStacksService([]);
+    await expect(service.remove('stack-1')).resolves.toEqual({ id: 'stack-1', deleted: true });
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/warehouses/delete-warehouse-guard.spec.ts b/apps/edr-freight-api/src/modules/warehouses/delete-warehouse-guard.spec.ts
new file mode 100644
index 000000000..c87f59886
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/delete-warehouse-guard.spec.ts
@@ -0,0 +1,46 @@
+import { ConflictException, NotFoundException } from '@nestjs/common';
+
+import { WarehousesService } from './warehouses.service';
+
+/**
+ * Deleting a warehouse that still holds yards would orphan every zone and the
+ * inventory sitting in them, so remove() refuses instead of cascading.
+ */
+function makeService(warehouse: unknown) {
+  const warehousesRepository = {
+    findById: jest.fn().mockResolvedValue(warehouse),
+    softDelete: jest.fn().mockResolvedValue(undefined),
+  };
+
+  const service = Object.create(WarehousesService.prototype) as Record<string, unknown>;
+  service.warehousesRepository = warehousesRepository;
+
+  return { service: service as unknown as WarehousesService, warehousesRepository };
+}
+
+describe('WarehousesService.remove', () => {
+  it('soft-deletes a warehouse with no yards', async () => {
+    const { service, warehousesRepository } = makeService({ id: 'w1', code: 'GMP', yards: [] });
+
+    await expect(service.remove('w1')).resolves.toEqual({ id: 'w1', deleted: true });
+    expect(warehousesRepository.softDelete).toHaveBeenCalledWith('w1');
+  });
+
+  it('refuses while yards remain', async () => {
+    const { service, warehousesRepository } = makeService({
+      id: 'w1',
+      code: 'GMP',
+      yards: [{ id: 'y1' }],
+    });
+
+    await expect(service.remove('w1')).rejects.toBeInstanceOf(ConflictException);
+    expect(warehousesRepository.softDelete).not.toHaveBeenCalled();
+  });
+
+  it('404s on an unknown warehouse', async () => {
+    const { service, warehousesRepository } = makeService(null);
+
+    await expect(service.remove('nope')).rejects.toBeInstanceOf(NotFoundException);
+    expect(warehousesRepository.softDelete).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/warehouses/delete-yard-zone-guards.spec.ts b/apps/edr-freight-api/src/modules/warehouses/delete-yard-zone-guards.spec.ts
new file mode 100644
index 000000000..6cd0001e3
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/delete-yard-zone-guards.spec.ts
@@ -0,0 +1,88 @@
+import { ConflictException, NotFoundException } from '@nestjs/common';
+
+import { WarehouseYardsService } from './warehouse-yards.service';
+import { WarehouseZonesService } from './warehouse-zones.service';
+
+/**
+ * Soft-deleting a parent would leave its children pointing at a row every
+ * joining query drops, so both removes refuse while children exist.
+ */
+function makeYardsService(yard: unknown) {
+  const yardsRepository = {
+    findById: jest.fn().mockResolvedValue(yard),
+    softDelete: jest.fn().mockResolvedValue(undefined),
+  };
+  const service = Object.create(WarehouseYardsService.prototype) as Record<string, unknown>;
+  service.yardsRepository = yardsRepository;
+  return { service: service as unknown as WarehouseYardsService, yardsRepository };
+}
+
+function makeZonesService(zone: unknown, heldInventory: number, configuredStacks = 0) {
+  const zonesRepository = {
+    findById: jest.fn().mockResolvedValue(zone),
+    softDelete: jest.fn().mockResolvedValue(undefined),
+  };
+  const inventoryRepository = {
+    findAndCount: jest.fn().mockResolvedValue([[], heldInventory]),
+  };
+  const service = Object.create(WarehouseZonesService.prototype) as Record<string, unknown>;
+  service.zonesRepository = zonesRepository;
+  service.inventoryRepository = inventoryRepository;
+  service.dataSource = { query: jest.fn().mockResolvedValue([{ count: configuredStacks }]) };
+  return { service: service as unknown as WarehouseZonesService, zonesRepository };
+}
+
+describe('WarehouseYardsService.remove', () => {
+  it('soft-deletes a yard with no zones', async () => {
+    const { service, yardsRepository } = makeYardsService({ id: 'y1', code: 'CY-A', zones: [] });
+
+    await expect(service.remove('y1')).resolves.toEqual({ id: 'y1', deleted: true });
+    expect(yardsRepository.softDelete).toHaveBeenCalledWith('y1');
+  });
+
+  it('refuses while zones remain', async () => {
+    const { service, yardsRepository } = makeYardsService({
+      id: 'y1',
+      code: 'CY-A',
+      zones: [{ id: 'z1' }],
+    });
+
+    await expect(service.remove('y1')).rejects.toBeInstanceOf(ConflictException);
+    expect(yardsRepository.softDelete).not.toHaveBeenCalled();
+  });
+
+  it('404s on an unknown yard', async () => {
+    const { service } = makeYardsService(null);
+
+    await expect(service.remove('nope')).rejects.toBeInstanceOf(NotFoundException);
+  });
+});
+
+describe('WarehouseZonesService.remove', () => {
+  it('soft-deletes an empty zone', async () => {
+    const { service, zonesRepository } = makeZonesService({ id: 'z1', code: 'ZA' }, 0);
+
+    await expect(service.remove('z1')).resolves.toEqual({ id: 'z1', deleted: true });
+    expect(zonesRepository.softDelete).toHaveBeenCalledWith('z1');
+  });
+
+  it('refuses while inventory sits in it', async () => {
+    const { service, zonesRepository } = makeZonesService({ id: 'z1', code: 'ZA' }, 16);
+
+    await expect(service.remove('z1')).rejects.toBeInstanceOf(ConflictException);
+    expect(zonesRepository.softDelete).not.toHaveBeenCalled();
+  });
+
+  it('refuses while ground stacks are still configured in it', async () => {
+    const { service, zonesRepository } = makeZonesService({ id: 'z1', code: 'ZA' }, 0, 20);
+
+    await expect(service.remove('z1')).rejects.toThrow(/still has 20 configured stack\(s\)/);
+    expect(zonesRepository.softDelete).not.toHaveBeenCalled();
+  });
+
+  it('404s on an unknown zone', async () => {
+    const { service } = makeZonesService(null, 0);
+
+    await expect(service.remove('nope')).rejects.toBeInstanceOf(NotFoundException);
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
index a99ca4f46..3928b6118 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/create-warehouse.dto.ts
@@ -1,7 +1,14 @@
 import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
 import { IsEnum, IsNumber, IsOptional, IsString, IsUUID, Matches, MaxLength, Min } from 'class-validator';
 
-import { WAREHOUSE_STATUSES, WAREHOUSE_TYPES, WarehouseStatus, WarehouseType } from '../entities/warehouse.entity';
+import {
+  FREIGHT_TYPES,
+  FreightType,
+  WAREHOUSE_STATUSES,
+  WAREHOUSE_TYPES,
+  WarehouseStatus,
+  WarehouseType,
+} from '../entities/warehouse.entity';
 
 export class CreateWarehouseDto {
   @ApiProperty()
@@ -19,6 +26,11 @@ export class CreateWarehouseDto {
   @IsEnum(WAREHOUSE_TYPES)
   type!: WarehouseType;
 
+  @ApiPropertyOptional({ enum: FREIGHT_TYPES, description: 'Omit for a warehouse that takes both.' })
+  @IsOptional()
+  @IsEnum(FREIGHT_TYPES)
+  freightType?: FreightType;
+
   @ApiPropertyOptional({ format: 'uuid' })
   @IsOptional()
   @IsUUID()
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/move-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/move-inventory.dto.ts
index 1aae7896f..c34c5fd61 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/move-inventory.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/move-inventory.dto.ts
@@ -14,6 +14,14 @@ export class MoveInventoryDto {
   @IsUUID()
   zoneId!: string;
 
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description: 'Exact physical slot in the destination zone. Container yards only.',
+  })
+  @IsOptional()
+  @IsUUID()
+  slotId?: string;
+
   @ApiPropertyOptional()
   @IsOptional()
   @IsString()
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/placement.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/placement.dto.ts
new file mode 100644
index 000000000..55c5a2d8f
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/placement.dto.ts
@@ -0,0 +1,33 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsIn, IsOptional, IsUUID } from 'class-validator';
+
+export class FindAvailableSlotDto {
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  yardId!: string;
+
+  @ApiPropertyOptional({ format: 'uuid', description: 'Narrow the search to one zone.' })
+  @IsOptional()
+  @IsUUID()
+  zoneId?: string;
+
+  @ApiPropertyOptional({ enum: ['IMPORT', 'EXPORT', 'BOTH'], description: 'Null/BOTH matches any yard direction.' })
+  @IsOptional()
+  @IsIn(['IMPORT', 'EXPORT', 'BOTH'])
+  direction?: string;
+
+  @ApiPropertyOptional({ format: 'uuid' })
+  @IsOptional()
+  @IsUUID()
+  cargoTypeId?: string;
+}
+
+export class AssignSlotDto {
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description: 'Target slot. Omit to let the placement engine pick the lowest free level.',
+  })
+  @IsOptional()
+  @IsUUID()
+  slotId?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/register-backlog.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/register-backlog.dto.ts
new file mode 100644
index 000000000..0c8ecde4b
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/register-backlog.dto.ts
@@ -0,0 +1,114 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  ArrayMaxSize,
+  ArrayMinSize,
+  IsArray,
+  IsDateString,
+  IsNumber,
+  IsOptional,
+  IsString,
+  IsUUID,
+  MaxLength,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+
+/**
+ * A loaded container that was already sitting in a yard before the system knew
+ * about it. It has no booking, so the owner is carried as a company reference
+ * or free text, and `arrivedAt` is the true historical arrival rather than now.
+ */
+export class RegisterBacklogContainerDto {
+  @ApiProperty({ description: 'ISO 6346 container number' })
+  @IsString()
+  @MaxLength(20)
+  containerNumber!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  containerTypeId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  warehouseId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  yardId!: string;
+
+  @ApiProperty({ format: 'uuid' })
+  @IsUUID()
+  zoneId!: string;
+
+  @ApiProperty({ description: 'True historical arrival date — drives nothing billable.' })
+  @IsDateString()
+  arrivedAt!: string;
+
+  @ApiPropertyOptional({ format: 'uuid', description: 'Registered customer, when the owner is one.' })
+  @IsOptional()
+  @IsUUID()
+  companyId?: string;
+
+  @ApiPropertyOptional({ description: 'Owner name — free text when the company is not a customer yet.' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(200)
+  companyName?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  sealNumber?: string;
+
+  @ApiPropertyOptional({ description: 'Net weight in the unit the warehouse records (tonnes).' })
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  weight?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  volume?: number;
+
+  /**
+   * ponytail: defaults to 0 when unknown, which is the honest value for a box
+   * nobody weighed. `containers.max_gross_weight` is a ceiling in
+   * cargoes.service, so set real figures here before this box is ever used for
+   * a new cargo assignment.
+   */
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  tareWeight?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsNumber()
+  @Min(0)
+  maxGrossWeight?: number;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  notes?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  performedBy?: string;
+}
+
+export class BulkRegisterBacklogDto {
+  @ApiProperty({ type: [RegisterBacklogContainerDto] })
+  @IsArray()
+  @ArrayMinSize(1)
+  @ArrayMaxSize(1000)
+  @ValidateNested({ each: true })
+  @Type(() => RegisterBacklogContainerDto)
+  containers!: RegisterBacklogContainerDto[];
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/store-inventory.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/store-inventory.dto.ts
index 08b15d536..1bdf1630a 100644
--- a/apps/edr-freight-api/src/modules/warehouses/dto/store-inventory.dto.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/store-inventory.dto.ts
@@ -22,6 +22,15 @@ export class StoreInventoryDto {
   @IsUUID()
   zoneId?: string;
 
+  @ApiPropertyOptional({
+    format: 'uuid',
+    description:
+      'Exact physical slot. Container yards only; omit to let the placement engine pick the lowest free level.',
+  })
+  @IsOptional()
+  @IsUUID()
+  slotId?: string;
+
   @ApiPropertyOptional()
   @IsOptional()
   @IsString()
diff --git a/apps/edr-freight-api/src/modules/warehouses/dto/warehouse-zone-stack.dto.ts b/apps/edr-freight-api/src/modules/warehouses/dto/warehouse-zone-stack.dto.ts
new file mode 100644
index 000000000..4006d6140
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/dto/warehouse-zone-stack.dto.ts
@@ -0,0 +1,120 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { IsBoolean, IsEnum, IsInt, IsOptional, IsString, IsUUID, Max, MaxLength, Min } from 'class-validator';
+
+import {
+  DEFAULT_MAX_STACK_HEIGHT,
+  WAREHOUSE_ZONE_STACK_STATUSES,
+  WarehouseZoneStackStatus,
+} from '../entities/warehouse-zone-stack.entity';
+import {
+  WAREHOUSE_ZONE_SLOT_STATUSES,
+  WarehouseZoneSlotStatus,
+} from '../entities/warehouse-zone-slot.entity';
+
+/** Nobody stacks boxes this high; the cap is here to catch a typo'd 30. */
+const MAX_SUPPORTED_STACK_HEIGHT = 10;
+
+export class CreateWarehouseZoneStackDto {
+  @ApiPropertyOptional({ format: 'uuid', description: 'Optional — taken from the route param when omitted' })
+  @IsOptional()
+  @IsUUID()
+  zoneId?: string;
+
+  @ApiProperty({ example: 'ZA-001' })
+  @IsString()
+  @MaxLength(40)
+  code!: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(160)
+  name?: string;
+
+  @ApiPropertyOptional({ description: 'Physical row label' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(20)
+  row?: string;
+
+  @ApiPropertyOptional({ description: 'Physical bay label' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(20)
+  bay?: string;
+
+  @ApiPropertyOptional({ description: 'Physical position label' })
+  @IsOptional()
+  @IsString()
+  @MaxLength(20)
+  position?: string;
+
+  @ApiPropertyOptional({
+    default: DEFAULT_MAX_STACK_HEIGHT,
+    description: 'One slot is generated per level, 1 to this height.',
+  })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(MAX_SUPPORTED_STACK_HEIGHT)
+  maxStackHeight?: number;
+}
+
+export class UpdateWarehouseZoneStackDto {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(40)
+  code?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(160)
+  name?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(20)
+  row?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(20)
+  bay?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  @MaxLength(20)
+  position?: string;
+
+  @ApiPropertyOptional({ description: 'Raising it adds slots; lowering it removes the empty top levels.' })
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  @Max(MAX_SUPPORTED_STACK_HEIGHT)
+  maxStackHeight?: number;
+
+  @ApiPropertyOptional({ enum: WAREHOUSE_ZONE_STACK_STATUSES })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_ZONE_STACK_STATUSES)
+  status?: WarehouseZoneStackStatus;
+}
+
+export class UpdateWarehouseZoneSlotDto {
+  @ApiPropertyOptional({
+    enum: WAREHOUSE_ZONE_SLOT_STATUSES,
+    description: 'Operator intent only. OCCUPIED is derived from inventory and cannot be set here.',
+  })
+  @IsOptional()
+  @IsEnum(WAREHOUSE_ZONE_SLOT_STATUSES)
+  status?: WarehouseZoneSlotStatus;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts
index b2c4ca3c4..61c810b7f 100644
--- a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-inventory.entity.ts
@@ -7,6 +7,8 @@ import { Container } from '../../container-management/entities/container.entity'
 import { Warehouse } from './warehouse.entity';
 import { WarehouseYard } from './warehouse-yard.entity';
 import { WarehouseZone } from './warehouse-zone.entity';
+import { WarehouseZoneSlot } from './warehouse-zone-slot.entity';
+import { WarehouseZoneStack } from './warehouse-zone-stack.entity';
 
 // Lifecycle. Supersedes the Batch 1 set
 // (ARRIVED_AT_WAREHOUSE / UNDER_INSPECTION / READY_FOR_LOADING) — migrated in place.
@@ -50,6 +52,23 @@ export const WAREHOUSE_INVENTORY_TRANSITIONS: Record<WarehouseInventoryStatus, W
   DELIVERED: [],
 };
 
+/**
+ * Statuses in which an inventory row is still physically standing in its slot.
+ * The moment it is LOADED onto a train, dispatched, or handed over, the ground
+ * is free again — so occupancy is read from this list rather than written to
+ * the slot row. The partial unique index in
+ * `WarehouseZoneStacksSlots3830000000000` uses exactly the same list; change
+ * one and you must change the other.
+ */
+export const SLOT_OCCUPYING_STATUSES: readonly WarehouseInventoryStatus[] = [
+  'UNLOADED',
+  'RECEIVED',
+  'STORED',
+  'RESERVED',
+  'READY_FOR_LOADING',
+  'READY_FOR_PICKUP',
+];
+
 @Entity({ schema: 'freight', name: 'warehouse_inventory' })
 @Index(['warehouseId'])
 @Index(['yardId'])
@@ -58,6 +77,8 @@ export const WAREHOUSE_INVENTORY_TRANSITIONS: Record<WarehouseInventoryStatus, W
 @Index(['cargoId'])
 @Index(['containerId'])
 @Index(['goodsId'])
+@Index(['stackId'])
+@Index(['slotId'])
 @Index(['status'])
 export class WarehouseInventory extends BaseEntity {
   @Column({ name: 'warehouse_id', type: 'uuid' })
@@ -81,6 +102,25 @@ export class WarehouseInventory extends BaseEntity {
   @JoinColumn({ name: 'zone_id' })
   zone?: WarehouseZone;
 
+  /**
+   * Exact physical position inside the zone. Nullable and additive: every row
+   * that predates the stack/slot model, and every non-container yard, keeps
+   * working with zone-level placement alone.
+   */
+  @Column({ name: 'stack_id', type: 'uuid', nullable: true })
+  stackId?: string | null;
+
+  @ManyToOne(() => WarehouseZoneStack, { nullable: true })
+  @JoinColumn({ name: 'stack_id' })
+  stack?: WarehouseZoneStack | null;
+
+  @Column({ name: 'slot_id', type: 'uuid', nullable: true })
+  slotId?: string | null;
+
+  @ManyToOne(() => WarehouseZoneSlot, { nullable: true })
+  @JoinColumn({ name: 'slot_id' })
+  slot?: WarehouseZoneSlot | null;
+
   @Column({ name: 'booking_id', type: 'uuid', nullable: true })
   bookingId?: string | null;
 
@@ -105,6 +145,22 @@ export class WarehouseInventory extends BaseEntity {
   @Column({ name: 'goods_id', type: 'uuid', nullable: true })
   goodsId?: string | null;
 
+  /**
+   * Registered as backlog: the box was already in the yard before the system
+   * knew about it. `arrivedAt` is the true, backdated arrival, but no storage
+   * or demurrage accrues — see WarehouseFeeService.previewForInventory.
+   */
+  @Column({ name: 'backlog_registration', type: 'boolean', default: false })
+  backlogRegistration!: boolean;
+
+  /** Owner of a row with no booking to inherit one from. */
+  @Column({ name: 'company_id', type: 'uuid', nullable: true })
+  companyId?: string | null;
+
+  /** Owner as text — a company that is not a registered customer yet. */
+  @Column({ name: 'company_name', type: 'varchar', length: 200, nullable: true })
+  companyName?: string | null;
+
   @Column({ name: 'quantity', type: 'numeric', precision: 12, scale: 3, default: 0 })
   quantity!: number;
 
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-zone-slot.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-zone-slot.entity.ts
new file mode 100644
index 000000000..d783ff300
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-zone-slot.entity.ts
@@ -0,0 +1,39 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne } from 'typeorm';
+
+import { WarehouseZoneStack } from './warehouse-zone-stack.entity';
+
+/**
+ * Stored slot status is *operator intent* only. Occupancy is never written
+ * here: it is derived from `warehouse_inventory.slot_id` plus the row's
+ * lifecycle status, so the two can never drift apart and no exit path
+ * (load / dispatch / deliver) has to remember to free a slot. The computed
+ * OCCUPIED value is what the API returns — see `SLOT_EFFECTIVE_STATUSES`.
+ */
+export const WAREHOUSE_ZONE_SLOT_STATUSES = ['AVAILABLE', 'BLOCKED', 'RESERVED', 'INACTIVE'] as const;
+export type WarehouseZoneSlotStatus = (typeof WAREHOUSE_ZONE_SLOT_STATUSES)[number];
+
+export const SLOT_EFFECTIVE_STATUSES = [...WAREHOUSE_ZONE_SLOT_STATUSES, 'OCCUPIED'] as const;
+export type SlotEffectiveStatus = (typeof SLOT_EFFECTIVE_STATUSES)[number];
+
+@Entity({ schema: 'freight', name: 'warehouse_zone_slots' })
+@Index(['stackId'])
+@Index(['status'])
+export class WarehouseZoneSlot extends BaseEntity {
+  @Column({ name: 'stack_id', type: 'uuid' })
+  stackId!: string;
+
+  @ManyToOne(() => WarehouseZoneStack, (stack) => stack.slots, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'stack_id' })
+  stack?: WarehouseZoneStack;
+
+  /** 1 = on the ground. Capped by the parent stack's maxStackHeight. */
+  @Column({ name: 'level', type: 'int' })
+  level!: number;
+
+  @Column({ name: 'status', type: 'varchar', length: 16, default: 'AVAILABLE' })
+  status!: WarehouseZoneSlotStatus;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-zone-stack.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-zone-stack.entity.ts
new file mode 100644
index 000000000..25add0f8e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse-zone-stack.entity.ts
@@ -0,0 +1,60 @@
+import { BaseEntity } from '@edr/api-common';
+import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
+
+import { WarehouseZone } from './warehouse-zone.entity';
+import { WarehouseZoneSlot } from './warehouse-zone-slot.entity';
+
+export const WAREHOUSE_ZONE_STACK_STATUSES = ['ACTIVE', 'INACTIVE'] as const;
+export type WarehouseZoneStackStatus = (typeof WAREHOUSE_ZONE_STACK_STATUSES)[number];
+
+/** Default vertical height of a container stack — three boxes, EDR's reach-stacker limit. */
+export const DEFAULT_MAX_STACK_HEIGHT = 3;
+
+/**
+ * One ground footprint inside a zone: the patch of concrete a container is put
+ * down on, and the levels above it. The zone is where allocation stops; this is
+ * where a box physically sits.
+ *
+ * Generic on purpose — a bulk or general-cargo zone may divide itself into
+ * stacks too — but the vertical stacking rules only run for CONTAINER_YARD.
+ */
+@Entity({ schema: 'freight', name: 'warehouse_zone_stacks' })
+@Index(['zoneId'])
+@Index(['status'])
+export class WarehouseZoneStack extends BaseEntity {
+  @Column({ name: 'zone_id', type: 'uuid' })
+  zoneId!: string;
+
+  @ManyToOne(() => WarehouseZone, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'zone_id' })
+  zone?: WarehouseZone;
+
+  /** Unique within the zone, e.g. ZA-001. */
+  @Column({ name: 'code', type: 'varchar', length: 40 })
+  code!: string;
+
+  @Column({ name: 'name', type: 'varchar', length: 160, nullable: true })
+  name?: string | null;
+
+  /** Free-form physical coordinates. Labels, not numbers — yards mix A/B/C with 1/2/3. */
+  @Column({ name: 'row', type: 'varchar', length: 20, nullable: true })
+  row?: string | null;
+
+  @Column({ name: 'bay', type: 'varchar', length: 20, nullable: true })
+  bay?: string | null;
+
+  @Column({ name: 'position', type: 'varchar', length: 20, nullable: true })
+  position?: string | null;
+
+  @Column({ name: 'max_stack_height', type: 'int', default: DEFAULT_MAX_STACK_HEIGHT })
+  maxStackHeight!: number;
+
+  @Column({ name: 'status', type: 'varchar', length: 16, default: 'ACTIVE' })
+  status!: WarehouseZoneStackStatus;
+
+  @Column({ name: 'is_active', type: 'boolean', default: true })
+  isActive!: boolean;
+
+  @OneToMany(() => WarehouseZoneSlot, (slot) => slot.stack)
+  slots?: WarehouseZoneSlot[];
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse.entity.ts b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse.entity.ts
index 267fcc8af..a67986ad1 100644
--- a/apps/edr-freight-api/src/modules/warehouses/entities/warehouse.entity.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/entities/warehouse.entity.ts
@@ -1,12 +1,16 @@
 import { BaseEntity } from '@edr/api-common';
 import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from 'typeorm';
 
+import { FREIGHT_TYPES, FreightType } from '../../bookings/entities/booking.entity';
 import { Facility } from '../../facilities/entities/facility.entity';
 import { WarehouseYard } from './warehouse-yard.entity';
 
 export const WAREHOUSE_TYPES = ['OPEN_WAREHOUSE', 'CLOSED_WAREHOUSE'] as const;
 export type WarehouseType = (typeof WAREHOUSE_TYPES)[number];
 
+export { FREIGHT_TYPES };
+export type { FreightType };
+
 export const WAREHOUSE_STATUSES = ['ACTIVE', 'INACTIVE'] as const;
 export type WarehouseStatus = (typeof WAREHOUSE_STATUSES)[number];
 
@@ -25,6 +29,14 @@ export class Warehouse extends BaseEntity {
   @Column({ name: 'type', type: 'varchar', length: 32 })
   type!: WarehouseType;
 
+  /**
+   * What the warehouse handles. Null means unrestricted — the pre-existing
+   * behaviour for every warehouse created before this field existed, so it
+   * never narrows an already-configured site.
+   */
+  @Column({ name: 'freight_type', type: 'varchar', length: 16, nullable: true })
+  freightType?: FreightType | null;
+
   @Column({ name: 'station_id', type: 'uuid', nullable: true })
   stationId?: string | null;
 
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
index 576933c01..c59cd0617 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-fee.service.ts
@@ -12,6 +12,8 @@ import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 
 interface ItemAttributes {
   arrivedAt: Date | null;
+  /** Backlog-registered box: real arrival on the record, but never billed. */
+  backlogRegistration: boolean;
   gateClearedAt: Date | null;
   releaseDate: Date | null;
   freightType: string | null;
@@ -260,6 +262,7 @@ export class WarehouseFeeService {
   private async loadItem(inventoryId: string): Promise<ItemAttributes> {
     const [row] = await this.dataSource.query(
       `SELECT inv.arrived_at        AS "arrivedAt",
+              inv.backlog_registration AS "backlogRegistration",
               inv.gate_cleared_at   AS "gateClearedAt",
               inv.release_date      AS "releaseDate",
               inv.quantity          AS "inventoryQuantity",
@@ -777,6 +780,13 @@ export class WarehouseFeeService {
   /** Preview demurrage + storage fees for an inventory item using the most specific active rules. */
   async previewForInventory(inventoryId: string, billingCurrency = 'USD'): Promise<FeePreview[]> {
     const item = await this.loadItem(inventoryId);
+
+    // A backlog registration carries a backdated arrival so the record is
+    // honest about how long the box has sat, but it was never booked through
+    // EDR and is not billed for that history. No rule applies, so no preview —
+    // which also keeps it off the invoice, since invoicing reads this same list.
+    if (item.backlogRegistration) return [];
+
     const rules = await this.feeRuleRepository.findAll({ where: { isActive: true } });
     const now = new Date();
 
@@ -894,6 +904,8 @@ export class WarehouseFeeService {
       trucks.map(async (t) => {
         const item: ItemAttributes = {
           arrivedAt: null,
+          // Truck detention is a per-truck charge, never a warehouse backlog row.
+          backlogRegistration: false,
           gateClearedAt: null,
           releaseDate: null,
           freightType: leg.freightType ?? null,
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
index 19d3b4b7a..15a3f6c4a 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.controller.ts
@@ -14,8 +14,13 @@ import { FilterWarehouseInventoryDto } from './dto/filter-inventory.dto';
 import { InquiryWarehouseInventoryDto } from './dto/inquiry-inventory.dto';
 import { LoadInventoryDto } from './dto/load-inventory.dto';
 import { MoveInventoryDto } from './dto/move-inventory.dto';
+import { AssignSlotDto, FindAvailableSlotDto } from './dto/placement.dto';
 import { StoreInventoryDto } from './dto/store-inventory.dto';
 import { ReceiveWarehouseInventoryDto } from './dto/receive-inventory.dto';
+import {
+  BulkRegisterBacklogDto,
+  RegisterBacklogContainerDto,
+} from './dto/register-backlog.dto';
 import { ApproveDeliveryDto } from './dto/approve-delivery.dto';
 import { SetDoubleHandlingDto } from './dto/double-handling.dto';
 import { ReleaseOrderDto } from './dto/release-order.dto';
@@ -143,6 +148,25 @@ export class WarehouseInventoryController {
     return this.inventoryService.eligibleBookings(dir);
   }
 
+  @Post('register-backlog')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.receive)
+  @ApiOperation({
+    summary: 'Register one loaded container already in the yard but never entered in the system',
+  })
+  registerBacklog(@Body() dto: RegisterBacklogContainerDto, @CurrentUser() user: TCurrentUser) {
+    dto.performedBy = actorLabel(user) ?? dto.performedBy;
+    return this.inventoryService.registerBacklogContainer(dto);
+  }
+
+  @Post('register-backlog-bulk')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.receive)
+  @ApiOperation({ summary: 'Bulk-register loaded containers already in the yard (Excel backlog)' })
+  registerBacklogBulk(@Body() dto: BulkRegisterBacklogDto, @CurrentUser() user: TCurrentUser) {
+    const performedBy = actorLabel(user);
+    dto.containers.forEach((c) => (c.performedBy = performedBy ?? c.performedBy));
+    return this.inventoryService.bulkRegisterBacklogContainers(dto);
+  }
+
   @Post('receive-bulk')
   @BookingStaff(FREIGHT_PERMS.warehouseInventory.receive)
   @ApiOperation({ summary: 'Bulk-receive selected eligible PAID bookings into a location' })
@@ -369,6 +393,50 @@ export class WarehouseInventoryController {
     return this.inventoryService.move(id, dto);
   }
 
+  @Post('placement/find-slot')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.move)
+  @ApiOperation({
+    summary: 'Lowest free stack level for a container yard',
+    description: 'Read-only preview of where the placement engine would put the next container.',
+  })
+  findAvailableSlot(@Body() dto: FindAvailableSlotDto) {
+    return this.inventoryService.findAvailableSlot(dto);
+  }
+
+  @Post(':id/assign-slot')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.move)
+  @ApiOperation({
+    summary: 'Place inventory at an exact stack level',
+    description: 'Omit slotId to take the lowest free level in the item\'s current zone.',
+  })
+  assignSlot(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: AssignSlotDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    return this.inventoryService.assignSlot(id, dto.slotId, actorLabel(user));
+  }
+
+  @Post(':id/release-slot')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.move)
+  @ApiOperation({
+    summary: 'Take inventory off its stack level',
+    description: 'Refused while other containers are stacked on top of it.',
+  })
+  releaseSlot(@Param('id', ParseUUIDPipe) id: string, @CurrentUser() user: TCurrentUser) {
+    return this.inventoryService.releaseSlot(id, actorLabel(user));
+  }
+
+  @Get(':id/accessibility')
+  @BookingStaff(FREIGHT_PERMS.warehouseInventory.view)
+  @ApiOperation({
+    summary: 'Can this container be lifted out',
+    description: 'Lists the containers stacked above it. Nothing is moved.',
+  })
+  accessibility(@Param('id', ParseUUIDPipe) id: string) {
+    return this.inventoryService.getContainerAccessibility(id);
+  }
+
   @Post(':id/store')
   @BookingStaff(FREIGHT_PERMS.warehouseInventory.move)
   @ApiOperation({ summary: 'Mark received inventory as STORED (optional explicit warehouse/yard/zone)' })
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
index 126998bae..aa032c17d 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-inventory.service.ts
@@ -50,6 +50,10 @@ import { InquiryWarehouseInventoryDto } from './dto/inquiry-inventory.dto';
 import { LoadInventoryDto } from './dto/load-inventory.dto';
 import { MoveInventoryDto } from './dto/move-inventory.dto';
 import { ReceiveWarehouseInventoryDto } from './dto/receive-inventory.dto';
+import {
+  BulkRegisterBacklogDto,
+  RegisterBacklogContainerDto,
+} from './dto/register-backlog.dto';
 import { ReleaseOrderDto } from './dto/release-order.dto';
 import { ReserveInventoryDto } from './dto/reserve-inventory.dto';
 import { UnloadBookingDto } from './dto/unload-booking.dto';
@@ -70,6 +74,7 @@ import { Warehouse } from './entities/warehouse.entity';
 import { SchedulingReadFacade } from './scheduling-read.facade';
 import { WarehouseActivityLogService } from './warehouse-activity-log.service';
 import { WarehouseInventoryRepository } from './warehouse-inventory.repository';
+import { WarehousePlacementService } from './warehouse-placement.service';
 import { WarehouseLoadingRepository } from './warehouse-loading.repository';
 import { WarehouseReleaseDocumentService } from './warehouse-release-document.service';
 import { HandoverService } from './handover.service';
@@ -412,6 +417,7 @@ export class WarehouseInventoryService {
     private readonly activityLog: WarehouseActivityLogService,
     private readonly scheduling: SchedulingReadFacade,
     private readonly allocation: WarehouseAllocationService,
+    private readonly placement: WarehousePlacementService,
     private readonly invoices: WarehouseInvoiceService,
     private readonly inspectionService: WarehouseInspectionService,
     private readonly releaseDocuments: WarehouseReleaseDocumentService,
@@ -2863,6 +2869,136 @@ export class WarehouseInventoryService {
     await this.lastMileService.acceptBooking(booking.reference);
   }
 
+  /**
+   * Register a loaded container that is already physically in a yard but was
+   * never entered in the system. Unlike receive(), there is no booking, no
+   * truck entrance to record (nobody remembers the driver of a box that has sat
+   * for months) and the arrival is backdated to when it actually turned up.
+   *
+   * The row is flagged `backlogRegistration`, which keeps the fee engine off it
+   * entirely — see WarehouseFeeService.previewForInventory. Capacity is still
+   * charged, because the box does occupy the yard.
+   */
+  async registerBacklogContainer(dto: RegisterBacklogContainerDto): Promise<WarehouseInventory> {
+    const id = await this.dataSource.transaction((manager) => this.saveBacklogContainer(manager, dto));
+    const saved = await this.inventoryRepository.findById(id);
+    if (!saved) throw new NotFoundException(`Inventory ${id} not found after registration`);
+    return saved;
+  }
+
+  /** The write itself, so single and bulk share one transaction each. */
+  private async saveBacklogContainer(
+    manager: EntityManager,
+    dto: RegisterBacklogContainerDto,
+  ): Promise<string> {
+    const containerNumber = dto.containerNumber.trim().toUpperCase();
+    const arrivedAt = new Date(dto.arrivedAt);
+    if (Number.isNaN(arrivedAt.getTime())) {
+      throw new BadRequestException(`Arrival date "${dto.arrivedAt}" is not a valid date`);
+    }
+    if (arrivedAt.getTime() > Date.now()) {
+      throw new BadRequestException('Arrival date cannot be in the future');
+    }
+
+    {
+      const { warehouse, yard, zone } = await this.validateLocation(manager, dto);
+
+      const containerType = await manager.query(
+        `SELECT id FROM freight.container_types WHERE id = $1 AND deleted_at IS NULL`,
+        [dto.containerTypeId],
+      );
+      if (containerType.length === 0) {
+        throw new NotFoundException(`Container type ${dto.containerTypeId} not found`);
+      }
+
+      // container_number is UNIQUE — reuse the existing record rather than
+      // colliding, so a box seen before keeps one identity.
+      const containers = manager.getRepository(Container);
+      let container = await containers.findOne({ where: { containerNumber } });
+      if (container) {
+        const alreadyHeld = await manager.getRepository(WarehouseInventory).findOne({
+          where: { containerId: container.id, status: In(['RECEIVED', 'STORED', 'READY_FOR_PICKUP']) },
+        });
+        if (alreadyHeld) {
+          throw new BadRequestException(
+            `Container ${containerNumber} is already in the warehouse (status ${alreadyHeld.status})`,
+          );
+        }
+      } else {
+        container = await containers.save(
+          containers.create({
+            containerNumber,
+            containerTypeId: dto.containerTypeId,
+            sealNumber: dto.sealNumber?.trim() || null,
+            tareWeight: dto.tareWeight ?? 0,
+            maxGrossWeight: dto.maxGrossWeight ?? 0,
+            status: 'LOADED',
+            bookingId: null,
+          }),
+        );
+      }
+
+      const weight = Number(dto.weight) || 0;
+      const volume = Number(dto.volume) || 0;
+      this.assertCapacity('Warehouse', warehouse, weight, volume, 1);
+      this.assertCapacity('Yard', yard, weight, volume, 1);
+      this.assertCapacity('Zone', zone, weight, volume, 1);
+
+      const owner = dto.companyName?.trim() || null;
+      const grnNumber = this.generateGrnNumber('WH', 'BACKLOG', arrivedAt, owner);
+      const saved = await manager.getRepository(WarehouseInventory).save(
+        manager.getRepository(WarehouseInventory).create({
+          warehouseId: dto.warehouseId,
+          yardId: dto.yardId,
+          zoneId: dto.zoneId,
+          bookingId: null,
+          containerId: container.id,
+          companyId: dto.companyId ?? null,
+          companyName: owner,
+          quantity: 1,
+          weight,
+          volume: dto.volume ?? null,
+          grnNumber,
+          status: 'RECEIVED',
+          arrivedAt,
+          backlogRegistration: true,
+          notes: this.buildReceiveNote({
+            grnNumber,
+            notes:
+              dto.notes?.trim() ||
+              `Backlog registration — already in yard, arrived ${arrivedAt.toISOString().slice(0, 10)}`,
+          }),
+        }),
+      );
+
+      await this.applyCapacityDelta(manager, dto, weight, volume, 1);
+      return saved.id;
+    }
+  }
+
+  /**
+   * Bulk backlog registration. All-or-nothing: one bad row rejects the sheet,
+   * so a half-registered yard can never happen.
+   */
+  async bulkRegisterBacklogContainers(dto: BulkRegisterBacklogDto): Promise<WarehouseInventory[]> {
+    const numbers = dto.containers.map((c) => c.containerNumber.trim().toUpperCase());
+    const seen = new Set<string>();
+    const repeated = [...new Set(numbers.filter((n) => (seen.has(n) ? true : (seen.add(n), false))))];
+    if (repeated.length > 0) {
+      throw new BadRequestException(`Container number(s) repeated in the upload: ${repeated.join(', ')}`);
+    }
+
+    const ids = await this.dataSource.transaction(async (manager) => {
+      const written: string[] = [];
+      for (const container of dto.containers) {
+        written.push(await this.saveBacklogContainer(manager, container));
+      }
+      return written;
+    });
+
+    return this.inventoryRepository.findAll({ where: { id: In(ids) } });
+  }
+
   async receive(dto: ReceiveWarehouseInventoryDto): Promise<WarehouseInventory> {
     const bookingDirection = dto.bookingId ? await this.getBookingDirection(dto.bookingId) : null;
     await this.assertExportBookingPaid(dto.bookingId, bookingDirection);
@@ -2996,12 +3132,37 @@ export class WarehouseInventoryService {
       if (
         item.warehouseId === dto.warehouseId &&
         item.yardId === dto.yardId &&
-        item.zoneId === dto.zoneId
+        item.zoneId === dto.zoneId &&
+        (item.slotId ?? null) === (dto.slotId ?? null)
       ) {
         throw new BadRequestException('Destination location is the same as current location');
       }
 
       const { warehouse, yard, zone } = await this.validateLocation(manager, dto);
+
+      // Taking a box out of a stack is physically impossible while others stand
+      // on top of it — the same rule the release path enforces. Moving is one of
+      // those exits, so it is checked here rather than only at release.
+      if (item.slotId) {
+        await this.placement.assertAccessible(item.id, manager);
+      }
+
+      // A move that names a slot is validated against the hierarchy it claims;
+      // one that does not clears the old slot, because the box has left it.
+      if (dto.slotId) {
+        await this.placement.validateSlotForInventory(
+          {
+            slotId: dto.slotId,
+            warehouseId: dto.warehouseId,
+            yardId: dto.yardId,
+            zoneId: dto.zoneId,
+            inventoryId: item.id,
+            quantity: Number(item.quantity) || 0,
+          },
+          manager,
+        );
+      }
+
       const weight = Number(item.weight) || 0;
       const containerCount = item.containerId ? Math.round(Number(item.quantity) || 0) : 0;
 
@@ -3011,7 +3172,12 @@ export class WarehouseInventoryService {
       if (item.yardId !== dto.yardId) {
         this.assertCapacity('Yard', yard, weight, Number(item.volume) || 0, containerCount);
       }
-      this.assertCapacity('Zone', zone, weight, Number(item.volume) || 0, containerCount);
+      // Skipped when the zone is unchanged: a slot-to-slot reshuffle inside one
+      // zone adds nothing to it, and a full zone would otherwise refuse to let
+      // its own containers be restacked.
+      if (item.zoneId !== dto.zoneId) {
+        this.assertCapacity('Zone', zone, weight, Number(item.volume) || 0, containerCount);
+      }
 
       await this.applyCapacityDelta(
         manager,
@@ -3030,6 +3196,14 @@ export class WarehouseInventoryService {
       item.warehouseId = dto.warehouseId;
       item.yardId = dto.yardId;
       item.zoneId = dto.zoneId;
+      if (dto.slotId) {
+        const slot = await this.placement.resolveSlot(dto.slotId, manager);
+        item.stackId = slot.stackId;
+        item.slotId = slot.slotId;
+      } else {
+        item.stackId = null;
+        item.slotId = null;
+      }
       if (dto.remarks?.trim()) {
         const existingNotes = item.notes?.trim();
         item.notes = existingNotes
@@ -3044,12 +3218,171 @@ export class WarehouseInventoryService {
     return this.findById(movedId);
   }
 
+  // ── Physical slot placement ──────────────────────────────────────────────
+
+  /**
+   * Pin an inventory item to an exact stack level, or let the placement engine
+   * pick the lowest free one. Transactional and locked: the row cannot be moved
+   * out from under the placement between validation and write.
+   */
+  async assignSlot(id: string, slotId?: string, performedBy?: string): Promise<WarehouseInventory> {
+    await this.dataSource.transaction(async (manager) => {
+      const item = await manager.getRepository(WarehouseInventory).findOne({
+        where: { id },
+        lock: { mode: 'pessimistic_write' },
+      });
+      if (!item) throw new NotFoundException(`Inventory item ${id} not found`);
+
+      const criteria = await this.getInventoryAllocationCriteria(item);
+      const chosenSlotId =
+        slotId ??
+        (
+          await this.placement.findAvailableContainerSlot(
+            { yardId: item.yardId, zoneId: item.zoneId, direction: criteria.tradeDirection },
+            manager,
+          )
+        )?.slotId;
+
+      if (!chosenSlotId) {
+        throw new BadRequestException('No free stack level is available in this zone');
+      }
+
+      const slot = await this.placement.validateSlotForInventory(
+        {
+          slotId: chosenSlotId,
+          warehouseId: item.warehouseId,
+          yardId: item.yardId,
+          zoneId: item.zoneId,
+          inventoryId: item.id,
+          quantity: Number(item.quantity) || 0,
+        },
+        manager,
+      );
+
+      await manager.getRepository(WarehouseInventory).update(id, {
+        stackId: slot.stackId,
+        slotId: slot.slotId,
+        notes: this.appendNote(item.notes, `Placed at ${slot.stackCode} level ${slot.level}`),
+      });
+
+      await this.activityLog.record(
+        {
+          activityType: 'INVENTORY_MOVED',
+          inventoryId: id,
+          warehouseId: item.warehouseId,
+          description: `Placed at ${slot.stackCode} level ${slot.level}`,
+          performedBy,
+        },
+        manager,
+      );
+    });
+
+    return this.findById(id);
+  }
+
+  /** Take the item off its stack level without moving it out of the zone. */
+  async releaseSlot(id: string, performedBy?: string): Promise<WarehouseInventory> {
+    await this.dataSource.transaction(async (manager) => {
+      const item = await manager.getRepository(WarehouseInventory).findOne({
+        where: { id },
+        lock: { mode: 'pessimistic_write' },
+      });
+      if (!item) throw new NotFoundException(`Inventory item ${id} not found`);
+      if (!item.slotId) return;
+
+      // Nothing may be standing on top of it — freeing a buried box would leave
+      // the containers above it floating over an empty level.
+      await this.placement.assertAccessible(id, manager);
+
+      await manager.getRepository(WarehouseInventory).update(id, { stackId: null, slotId: null });
+      await this.activityLog.record(
+        {
+          activityType: 'INVENTORY_MOVED',
+          inventoryId: id,
+          warehouseId: item.warehouseId,
+          description: 'Released from its stack level',
+          performedBy,
+        },
+        manager,
+      );
+    });
+
+    return this.findById(id);
+  }
+
+  /** Whether the box can be lifted out, and what is stacked on top of it if not. */
+  getContainerAccessibility(id: string) {
+    return this.placement.getContainerAccessibility(id);
+  }
+
+  /** Lowest free stack level for the given yard/zone, without assigning it. */
+  findAvailableSlot(input: {
+    yardId: string;
+    zoneId?: string;
+    direction?: string;
+    cargoTypeId?: string;
+  }) {
+    return this.placement.findAvailableContainerSlot(input);
+  }
+
+  /**
+   * The physical position an item should take when it is stored.
+   *
+   * An explicitly chosen slot is validated and any failure is surfaced — the
+   * operator asked for that exact level. The automatic path is best-effort:
+   * a yard with no stacks configured yet, or one that is full, falls back to
+   * plain zone-level storage rather than blocking a store that worked before
+   * this model existed.
+   */
+  private async resolveStoragePlacement(
+    manager: EntityManager,
+    item: WarehouseInventory,
+    location: LocationRef,
+    options: { slotId?: string; direction?: string | null },
+  ): Promise<{ stackId: string; slotId: string; label: string } | null> {
+    const yard = await manager.getRepository(WarehouseYard).findOne({ where: { id: location.yardId } });
+    if (yard?.type !== 'CONTAINER_YARD') return null;
+
+    if (options.slotId) {
+      const slot = await this.placement.validateSlotForInventory(
+        {
+          slotId: options.slotId,
+          warehouseId: location.warehouseId,
+          yardId: location.yardId,
+          zoneId: location.zoneId,
+          inventoryId: item.id,
+          quantity: Number(item.quantity) || 0,
+        },
+        manager,
+      );
+      return { stackId: slot.stackId, slotId: slot.slotId, label: `${slot.stackCode} level ${slot.level}` };
+    }
+
+    // A row still covering several containers has no single position to take.
+    if ((Number(item.quantity) || 0) > 1) return null;
+
+    try {
+      const found = await this.placement.findAvailableContainerSlot(
+        { yardId: location.yardId, zoneId: location.zoneId, direction: options.direction },
+        manager,
+      );
+      return found
+        ? { stackId: found.stackId, slotId: found.slotId, label: `${found.stackCode} level ${found.level}` }
+        : null;
+    } catch (error) {
+      this.logger.debug(
+        `Automatic slot placement skipped for inventory ${item.id}: ${(error as Error).message}`,
+      );
+      return null;
+    }
+  }
+
   // ── Lifecycle transitions ────────────────────────────────────────────────
 
   async store(
     id: string,
     performedBy?: string,
-    chosen?: { warehouseId?: string; yardId?: string; zoneId?: string },
+    chosen?: { warehouseId?: string; yardId?: string; zoneId?: string; slotId?: string },
   ): Promise<WarehouseInventory> {
     const item = await this.findById(id);
     this.assertTransition(item.status, 'STORED');
@@ -3113,11 +3446,17 @@ export class WarehouseInventoryService {
         await this.applyCapacityDelta(manager, location, weight, volume, containerCount);
       }
 
-      const storedReason = manualLocation
+      const placed = await this.resolveStoragePlacement(manager, locked, location, {
+        slotId: chosen?.slotId,
+        direction: criteria.tradeDirection,
+      });
+
+      const baseReason = manualLocation
         ? `Stored at operator-selected location -> ${location.path ?? 'chosen yard/zone'}`
         : ruleLocation?.rule
           ? `Stored by allocation rule "${ruleLocation.rule.name}" -> ${ruleLocation.path}`
           : `Stored by capacity-balanced allocation -> ${location.path ?? 'assigned yard/zone'}`;
+      const storedReason = placed ? `${baseReason} @ ${placed.label}` : baseReason;
 
       await manager.getRepository(WarehouseInventory).update(id, {
         status: 'STORED',
@@ -3125,6 +3464,8 @@ export class WarehouseInventoryService {
         warehouseId: location.warehouseId,
         yardId: location.yardId,
         zoneId: location.zoneId,
+        stackId: placed?.stackId ?? null,
+        slotId: placed?.slotId ?? null,
         notes: this.appendNote(locked.notes, storedReason),
       });
 
@@ -6029,6 +6370,18 @@ export class WarehouseInventoryService {
     if (!yard) throw new NotFoundException(`Yard ${dto.yardId} not found`);
     const zone = await manager.getRepository(WarehouseZone).findOne({ where: { id: dto.zoneId } });
     if (!zone) throw new NotFoundException(`Zone ${dto.zoneId} not found`);
+
+    // The three ids arrive independently from the client, so they have to be
+    // checked against each other: a zone belonging to another yard would send
+    // the item to a location that does not exist on the ground, and every
+    // capacity counter above it would be adjusted on the wrong row.
+    if (zone.yardId !== yard.id) {
+      throw new BadRequestException(`Zone ${zone.code} does not belong to yard ${yard.code}`);
+    }
+    if (yard.warehouseId !== warehouse.id) {
+      throw new BadRequestException(`Yard ${yard.code} does not belong to warehouse ${warehouse.code}`);
+    }
+
     return { warehouse, yard, zone };
   }
 
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-placement.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-placement.service.ts
new file mode 100644
index 000000000..7e70a6e15
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-placement.service.ts
@@ -0,0 +1,644 @@
+import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { DataSource, EntityManager } from 'typeorm';
+
+import {
+  SLOT_OCCUPYING_STATUSES,
+  WarehouseInventory,
+} from './entities/warehouse-inventory.entity';
+import { SlotEffectiveStatus } from './entities/warehouse-zone-slot.entity';
+
+/** The whole chain above one slot, resolved server-side in a single join. */
+export interface SlotHierarchy {
+  slotId: string;
+  slotStatus: string;
+  slotIsActive: boolean;
+  level: number;
+  stackId: string;
+  stackCode: string;
+  stackStatus: string;
+  stackIsActive: boolean;
+  maxStackHeight: number;
+  zoneId: string;
+  zoneCode: string;
+  zoneType: string;
+  zoneStatus: string;
+  zoneIsActive: boolean;
+  yardId: string;
+  yardCode: string;
+  yardType: string;
+  yardDirection: string | null;
+  yardStatus: string;
+  yardIsActive: boolean;
+  warehouseId: string;
+  warehouseCode: string;
+  warehouseStatus: string;
+  warehouseIsActive: boolean;
+}
+
+export interface AvailableSlot {
+  slotId: string;
+  stackId: string;
+  stackCode: string;
+  level: number;
+  zoneId: string;
+  zoneCode: string;
+}
+
+export interface FindSlotInput {
+  yardId: string;
+  zoneId?: string | null;
+  /** IMPORT | EXPORT — matched against the yard's direction (null = BOTH). */
+  direction?: string | null;
+  cargoTypeId?: string | null;
+}
+
+export interface BlockingContainer {
+  inventoryId: string;
+  containerNumber: string | null;
+  level: number;
+  status: string;
+}
+
+export interface ContainerAccessibility {
+  accessible: boolean;
+  inventoryId: string;
+  stackCode: string | null;
+  level: number | null;
+  blockingContainers: BlockingContainer[];
+}
+
+export interface SlotSummary {
+  configuredCapacity: number | null;
+  physicalSlotCount: number;
+  occupiedSlotCount: number;
+  reservedSlotCount: number;
+  blockedSlotCount: number;
+  inactiveSlotCount: number;
+  availableSlotCount: number;
+  /** True when more physical slots are built than the configured capacity allows. */
+  inconsistent: boolean;
+}
+
+export interface ZoneLayoutSlot {
+  slotId: string;
+  level: number;
+  effectiveStatus: SlotEffectiveStatus;
+  inventoryId: string | null;
+  containerNumber: string | null;
+}
+
+export interface ZoneLayoutStack {
+  stackId: string;
+  code: string;
+  name: string | null;
+  maxStackHeight: number;
+  status: string;
+  isActive: boolean;
+  slots: ZoneLayoutSlot[];
+}
+
+export interface ZoneLayout {
+  zoneId: string;
+  zoneCode: string;
+  zoneName: string;
+  stacks: ZoneLayoutStack[];
+  summary: SlotSummary;
+}
+
+/**
+ * Container identity has two sources and neither covers the other: a backlog
+ * registration points `warehouse_inventory.container_id` at a `containers` row,
+ * while booked cargo carries its numbers on `booking_container_units`. Scalar
+ * subselects rather than joins, so one slot can never fan out into many rows.
+ * A booking whose units were never split into one inventory row each shows the
+ * first unit number — placement refuses such rows anyway (see assertSingleUnit).
+ */
+const CONTAINER_NUMBER_EXPR = `COALESCE(
+  (SELECT c.container_number FROM freight.containers c
+    WHERE c.id = i.container_id AND c.deleted_at IS NULL),
+  (SELECT bcu.container_number FROM freight.booking_container_units bcu
+     JOIN freight.booking_container bc ON bc.id = bcu.booking_container_id AND bc.deleted_at IS NULL
+    WHERE bc.booking_id = i.booking_id AND bcu.deleted_at IS NULL
+    ORDER BY bcu.container_number
+    LIMIT 1)
+)`;
+
+/** A row is "standing in its slot" only in these statuses — same list as the DB's partial unique index. */
+const OCCUPYING = SLOT_OCCUPYING_STATUSES as unknown as string[];
+
+/**
+ * Physical container placement: the stage after allocation. Allocation picks a
+ * yard (and maybe a zone) from configured rules; this picks the exact stack and
+ * level, enforces the stacking rules, and answers whether a box can be reached.
+ *
+ * Nothing here is called for a non-container yard — bulk, general cargo,
+ * hazardous and cold storage keep zone-level placement.
+ */
+@Injectable()
+export class WarehousePlacementService {
+  constructor(@InjectDataSource() private readonly dataSource: DataSource) {}
+
+  private em(manager?: EntityManager): EntityManager | DataSource {
+    return manager ?? this.dataSource;
+  }
+
+  // ── Hierarchy ─────────────────────────────────────────────────────────────
+
+  /**
+   * Resolve a slot's full chain up to the warehouse. Ids arriving from a client
+   * are never trusted against one another — this is the one place the chain is
+   * established, and every caller compares against what comes back here.
+   */
+  async resolveSlot(slotId: string, manager?: EntityManager): Promise<SlotHierarchy> {
+    const [row] = await this.em(manager).query(
+      `SELECT sl.id AS "slotId", sl.status AS "slotStatus", sl.is_active AS "slotIsActive",
+              sl.level AS "level",
+              s.id AS "stackId", s.code AS "stackCode", s.status AS "stackStatus",
+              s.is_active AS "stackIsActive", s.max_stack_height AS "maxStackHeight",
+              z.id AS "zoneId", z.code AS "zoneCode", z.type AS "zoneType",
+              z.status AS "zoneStatus", z.is_active AS "zoneIsActive",
+              y.id AS "yardId", y.code AS "yardCode", y.type AS "yardType",
+              y.direction AS "yardDirection", y.status AS "yardStatus", y.is_active AS "yardIsActive",
+              w.id AS "warehouseId", w.code AS "warehouseCode",
+              w.status AS "warehouseStatus", w.is_active AS "warehouseIsActive"
+         FROM freight.warehouse_zone_slots sl
+         JOIN freight.warehouse_zone_stacks s ON s.id = sl.stack_id AND s.deleted_at IS NULL
+         JOIN freight.warehouse_zones z ON z.id = s.zone_id AND z.deleted_at IS NULL
+         JOIN freight.warehouse_yards y ON y.id = z.yard_id AND y.deleted_at IS NULL
+         JOIN freight.warehouses w ON w.id = y.warehouse_id AND w.deleted_at IS NULL
+        WHERE sl.id = $1 AND sl.deleted_at IS NULL`,
+      [slotId],
+    );
+
+    if (!row) throw new NotFoundException(`Slot ${slotId} not found`);
+    return row as SlotHierarchy;
+  }
+
+  /** Levels in a stack currently holding a container, lowest first. */
+  async occupiedLevels(
+    stackId: string,
+    excludeInventoryId?: string | null,
+    manager?: EntityManager,
+  ): Promise<number[]> {
+    const rows: Array<{ level: number }> = await this.em(manager).query(
+      `SELECT sl.level AS "level"
+         FROM freight.warehouse_zone_slots sl
+         JOIN freight.warehouse_inventory i
+           ON i.slot_id = sl.id AND i.deleted_at IS NULL AND i.status = ANY($2)
+        WHERE sl.stack_id = $1 AND sl.deleted_at IS NULL
+          AND ($3::uuid IS NULL OR i.id <> $3::uuid)
+        ORDER BY sl.level`,
+      [stackId, OCCUPYING, excludeInventoryId ?? null],
+    );
+    return rows.map((r) => Number(r.level));
+  }
+
+  // ── Placement validation ──────────────────────────────────────────────────
+
+  /**
+   * Every check that must pass before a container may stand in a slot, in the
+   * order a yard operator would hit them. Returns the resolved hierarchy so the
+   * caller writes ids it did not invent.
+   */
+  async validateSlotForInventory(
+    input: {
+      slotId: string;
+      warehouseId: string;
+      yardId: string;
+      zoneId: string;
+      /** Excluded from occupancy checks — the row being moved is allowed to leave its own slot. */
+      inventoryId?: string | null;
+      quantity?: number | null;
+    },
+    manager?: EntityManager,
+  ): Promise<SlotHierarchy> {
+    const slot = await this.resolveSlot(input.slotId, manager);
+
+    // 1. Hierarchy — the client may not staple a slot onto an unrelated zone/yard/warehouse.
+    if (slot.zoneId !== input.zoneId) {
+      throw new BadRequestException(
+        `Slot ${slot.stackCode}/L${slot.level} belongs to zone ${slot.zoneCode}, not the zone given`,
+      );
+    }
+    if (slot.yardId !== input.yardId) {
+      throw new BadRequestException(`Zone ${slot.zoneCode} belongs to yard ${slot.yardCode}, not the yard given`);
+    }
+    if (slot.warehouseId !== input.warehouseId) {
+      throw new BadRequestException(
+        `Yard ${slot.yardCode} belongs to warehouse ${slot.warehouseCode}, not the warehouse given`,
+      );
+    }
+
+    // 2. Every level of the chain has to be operationally open.
+    this.assertOperational('Warehouse', slot.warehouseCode, slot.warehouseStatus, slot.warehouseIsActive);
+    this.assertOperational('Yard', slot.yardCode, slot.yardStatus, slot.yardIsActive);
+    this.assertOperational('Zone', slot.zoneCode, slot.zoneStatus, slot.zoneIsActive);
+    this.assertOperational('Stack', slot.stackCode, slot.stackStatus, slot.stackIsActive);
+
+    if (!slot.slotIsActive) {
+      throw new BadRequestException(`Slot ${slot.stackCode}/L${slot.level} is inactive`);
+    }
+    // RESERVED is accepted: a slot is reserved *for* the box now arriving.
+    if (slot.slotStatus !== 'AVAILABLE' && slot.slotStatus !== 'RESERVED') {
+      throw new BadRequestException(`Slot ${slot.stackCode}/L${slot.level} is ${slot.slotStatus}`);
+    }
+
+    // 3. One box per slot. The DB's partial unique index is the backstop; this
+    //    is the readable error the operator actually gets.
+    const [taken] = await this.em(manager).query(
+      `SELECT i.id FROM freight.warehouse_inventory i
+        WHERE i.slot_id = $1 AND i.deleted_at IS NULL AND i.status = ANY($2)
+          AND ($3::uuid IS NULL OR i.id <> $3::uuid)
+        LIMIT 1`,
+      [input.slotId, OCCUPYING, input.inventoryId ?? null],
+    );
+    if (taken) {
+      throw new ConflictException(`Slot ${slot.stackCode}/L${slot.level} is already occupied`);
+    }
+
+    if (slot.level > slot.maxStackHeight) {
+      throw new BadRequestException(
+        `Level ${slot.level} is above stack ${slot.stackCode}'s maximum height of ${slot.maxStackHeight}`,
+      );
+    }
+
+    // 4. Container yards only: no box may float above an empty level, and a row
+    //    covering several containers has no single physical position.
+    if (slot.yardType === 'CONTAINER_YARD') {
+      this.assertSingleUnit(input.quantity);
+      const occupied = await this.occupiedLevels(slot.stackId, input.inventoryId ?? null, manager);
+      this.assertStackable(slot, occupied);
+    }
+
+    return slot;
+  }
+
+  private assertOperational(label: string, code: string, status: string, isActive: boolean): void {
+    if (status !== 'ACTIVE' || !isActive) {
+      throw new BadRequestException(`${label} ${code} is not active`);
+    }
+  }
+
+  /**
+   * A slot is one container. A row that still carries several boxes has no
+   * single position — split it before placing it, rather than silently pinning
+   * five containers to one level.
+   */
+  private assertSingleUnit(quantity?: number | null): void {
+    const qty = Number(quantity ?? 1);
+    if (qty > 1) {
+      throw new BadRequestException(
+        `This inventory row covers ${qty} containers. Split it into one row per container before assigning a slot.`,
+      );
+    }
+  }
+
+  /** Level N needs every level below it filled — nothing hovers. */
+  assertStackable(slot: Pick<SlotHierarchy, 'level' | 'stackCode'>, occupiedLevels: number[]): void {
+    if (slot.level === 1) return;
+    const missing: number[] = [];
+    for (let level = 1; level < slot.level; level += 1) {
+      if (!occupiedLevels.includes(level)) missing.push(level);
+    }
+    if (missing.length > 0) {
+      throw new BadRequestException(
+        `Stack ${slot.stackCode}: level ${slot.level} cannot be filled while level(s) ${missing.join(', ')} are empty`,
+      );
+    }
+  }
+
+  // ── Finding a slot ────────────────────────────────────────────────────────
+
+  /**
+   * Lowest valid free level, deterministic: zone code, then stack code, then
+   * level. Bottom-up by construction — a stack's candidate level is always one
+   * above its current top, so level 2 can never be picked before level 1.
+   *
+   * Isolated on purpose: a smarter strategy (weight, direction, dwell time)
+   * swaps in here without touching any caller.
+   */
+  async findAvailableContainerSlot(input: FindSlotInput, manager?: EntityManager): Promise<AvailableSlot | null> {
+    const yard = await this.loadYardForPlacement(input, manager);
+    const zoneIds = await this.candidateZoneIds(yard.id, input.zoneId ?? null, manager);
+    if (zoneIds.length === 0) return null;
+
+    const [slot] = await this.em(manager).query(
+      `SELECT sl.id AS "slotId", s.id AS "stackId", s.code AS "stackCode",
+              sl.level AS "level", z.id AS "zoneId", z.code AS "zoneCode"
+         FROM freight.warehouse_zone_stacks s
+         JOIN freight.warehouse_zones z ON z.id = s.zone_id AND z.deleted_at IS NULL
+         CROSS JOIN LATERAL (
+           SELECT COALESCE(MAX(sl2.level), 0) AS top
+             FROM freight.warehouse_zone_slots sl2
+             JOIN freight.warehouse_inventory i2
+               ON i2.slot_id = sl2.id AND i2.deleted_at IS NULL AND i2.status = ANY($2)
+            WHERE sl2.stack_id = s.id AND sl2.deleted_at IS NULL
+         ) occ
+         JOIN freight.warehouse_zone_slots sl
+           ON sl.stack_id = s.id AND sl.deleted_at IS NULL
+          AND sl.level = occ.top + 1
+          AND sl.status = 'AVAILABLE' AND sl.is_active = true
+        WHERE s.zone_id = ANY($1::uuid[])
+          AND s.deleted_at IS NULL AND s.status = 'ACTIVE' AND s.is_active = true
+          AND occ.top < s.max_stack_height
+        ORDER BY z.code, s.code, sl.level
+        LIMIT 1`,
+      [zoneIds, OCCUPYING],
+    );
+
+    return (slot as AvailableSlot) ?? null;
+  }
+
+  /** Yard gates: active, a container yard, right direction, right cargo type. */
+  private async loadYardForPlacement(
+    input: FindSlotInput,
+    manager?: EntityManager,
+  ): Promise<{ id: string; code: string }> {
+    const [yard] = await this.em(manager).query(
+      `SELECT y.id, y.code, y.type, y.direction, y.status, y.is_active AS "isActive",
+              y.capacity_containers AS "capacityContainers", y.current_containers AS "currentContainers",
+              w.status AS "warehouseStatus", w.is_active AS "warehouseIsActive", w.code AS "warehouseCode"
+         FROM freight.warehouse_yards y
+         JOIN freight.warehouses w ON w.id = y.warehouse_id AND w.deleted_at IS NULL
+        WHERE y.id = $1 AND y.deleted_at IS NULL`,
+      [input.yardId],
+    );
+    if (!yard) throw new NotFoundException(`Yard ${input.yardId} not found`);
+
+    this.assertOperational('Warehouse', yard.warehouseCode, yard.warehouseStatus, yard.warehouseIsActive);
+    this.assertOperational('Yard', yard.code, yard.status, yard.isActive);
+
+    if (yard.type !== 'CONTAINER_YARD') {
+      throw new BadRequestException(`Yard ${yard.code} is a ${yard.type}; container stacking does not apply`);
+    }
+
+    // Null direction has always meant "takes both" — never treat it as invalid.
+    const yardDirection = yard.direction ?? 'BOTH';
+    const wanted = input.direction ?? 'BOTH';
+    if (yardDirection !== 'BOTH' && wanted !== 'BOTH' && yardDirection !== wanted) {
+      throw new BadRequestException(`Yard ${yard.code} serves ${yardDirection} traffic, not ${wanted}`);
+    }
+
+    // Empty cargo-type relation = open to any cargo. Preserved deliberately.
+    if (input.cargoTypeId) {
+      const [{ allowed }] = await this.em(manager).query(
+        `SELECT (NOT EXISTS (SELECT 1 FROM freight.warehouse_yard_cargo_types t WHERE t.yard_id = $1)
+                 OR EXISTS (SELECT 1 FROM freight.warehouse_yard_cargo_types t
+                             WHERE t.yard_id = $1 AND t.cargo_type_id = $2)) AS allowed`,
+        [yard.id, input.cargoTypeId],
+      );
+      if (!allowed) {
+        throw new BadRequestException(`Yard ${yard.code} does not accept this cargo type`);
+      }
+    }
+
+    if (yard.capacityContainers != null && Number(yard.currentContainers) >= Number(yard.capacityContainers)) {
+      throw new BadRequestException(
+        `Yard ${yard.code} is at its configured capacity (${yard.currentContainers}/${yard.capacityContainers})`,
+      );
+    }
+
+    return { id: yard.id, code: yard.code };
+  }
+
+  /** Active container zones in the yard with configured capacity left, in code order. */
+  private async candidateZoneIds(
+    yardId: string,
+    zoneId: string | null,
+    manager?: EntityManager,
+  ): Promise<string[]> {
+    const rows: Array<{ id: string }> = await this.em(manager).query(
+      `SELECT z.id
+         FROM freight.warehouse_zones z
+        WHERE z.yard_id = $1 AND z.deleted_at IS NULL
+          AND z.status = 'ACTIVE' AND z.is_active = true
+          AND z.type = 'CONTAINER_ZONE'
+          AND (z.capacity_containers IS NULL OR z.current_containers < z.capacity_containers)
+          AND ($2::uuid IS NULL OR z.id = $2::uuid)
+        ORDER BY z.code`,
+      [yardId, zoneId],
+    );
+    return rows.map((r) => r.id);
+  }
+
+  // ── Accessibility ─────────────────────────────────────────────────────────
+
+  /**
+   * Whether a box can be taken out without touching anything else. Containers
+   * standing above it block it; nothing is moved to clear the way — a
+   * relocation is an operator decision, not a side effect of a read.
+   */
+  async getContainerAccessibility(inventoryId: string, manager?: EntityManager): Promise<ContainerAccessibility> {
+    const [placed] = await this.em(manager).query(
+      `SELECT i.id AS "inventoryId", sl.level AS "level", s.id AS "stackId", s.code AS "stackCode"
+         FROM freight.warehouse_inventory i
+         LEFT JOIN freight.warehouse_zone_slots sl ON sl.id = i.slot_id AND sl.deleted_at IS NULL
+         LEFT JOIN freight.warehouse_zone_stacks s ON s.id = sl.stack_id AND s.deleted_at IS NULL
+        WHERE i.id = $1 AND i.deleted_at IS NULL`,
+      [inventoryId],
+    );
+
+    if (!placed) throw new NotFoundException(`Inventory item ${inventoryId} not found`);
+
+    // No slot = zone-level placement (bulk, or an item that predates the model):
+    // nothing is stacked on it, so it is reachable.
+    if (!placed.stackId) {
+      return { accessible: true, inventoryId, stackCode: null, level: null, blockingContainers: [] };
+    }
+
+    const blocking: BlockingContainer[] = await this.em(manager).query(
+      `SELECT i.id AS "inventoryId", sl.level AS "level", i.status AS "status",
+              ${CONTAINER_NUMBER_EXPR} AS "containerNumber"
+         FROM freight.warehouse_zone_slots sl
+         JOIN freight.warehouse_inventory i
+           ON i.slot_id = sl.id AND i.deleted_at IS NULL AND i.status = ANY($3)
+        WHERE sl.stack_id = $1 AND sl.deleted_at IS NULL AND sl.level > $2
+        ORDER BY sl.level DESC`,
+      [placed.stackId, Number(placed.level), OCCUPYING],
+    );
+
+    return {
+      accessible: blocking.length === 0,
+      inventoryId,
+      stackCode: placed.stackCode,
+      level: Number(placed.level),
+      blockingContainers: blocking.map((b) => ({ ...b, level: Number(b.level) })),
+    };
+  }
+
+  /** Refuse to hand out a box that is buried — used by the exit/delivery paths. */
+  async assertAccessible(inventoryId: string, manager?: EntityManager): Promise<void> {
+    const access = await this.getContainerAccessibility(inventoryId, manager);
+    if (!access.accessible) {
+      const above = access.blockingContainers
+        .map((b) => `${b.containerNumber ?? b.inventoryId} (L${b.level})`)
+        .join(', ');
+      throw new ConflictException(
+        `Container is at ${access.stackCode}/L${access.level} with ${above} stacked above it. Relocate those first.`,
+      );
+    }
+  }
+
+  // ── Reads ─────────────────────────────────────────────────────────────────
+
+  /** Physical layout of one zone: every stack, every level, what stands there. */
+  async zoneLayout(zoneId: string, manager?: EntityManager): Promise<ZoneLayout> {
+    const [zone] = await this.em(manager).query(
+      `SELECT z.id, z.code, z.name, z.capacity_containers AS "capacityContainers"
+         FROM freight.warehouse_zones z WHERE z.id = $1 AND z.deleted_at IS NULL`,
+      [zoneId],
+    );
+    if (!zone) throw new NotFoundException(`Warehouse zone ${zoneId} not found`);
+
+    const rows: Array<{
+      stackId: string;
+      code: string;
+      name: string | null;
+      maxStackHeight: number;
+      stackStatus: string;
+      stackIsActive: boolean;
+      slotId: string | null;
+      level: number | null;
+      slotStatus: string | null;
+      slotIsActive: boolean | null;
+      inventoryId: string | null;
+      containerNumber: string | null;
+    }> = await this.em(manager).query(
+      `SELECT s.id AS "stackId", s.code AS "code", s.name AS "name",
+              s.max_stack_height AS "maxStackHeight", s.status AS "stackStatus",
+              s.is_active AS "stackIsActive",
+              sl.id AS "slotId", sl.level AS "level", sl.status AS "slotStatus",
+              sl.is_active AS "slotIsActive",
+              i.id AS "inventoryId",
+              CASE WHEN i.id IS NULL THEN NULL ELSE ${CONTAINER_NUMBER_EXPR} END AS "containerNumber"
+         FROM freight.warehouse_zone_stacks s
+         LEFT JOIN freight.warehouse_zone_slots sl ON sl.stack_id = s.id AND sl.deleted_at IS NULL
+         LEFT JOIN freight.warehouse_inventory i
+                ON i.slot_id = sl.id AND i.deleted_at IS NULL AND i.status = ANY($2)
+        WHERE s.zone_id = $1 AND s.deleted_at IS NULL
+        ORDER BY s.code, sl.level DESC`,
+      [zoneId, OCCUPYING],
+    );
+
+    const stacks = new Map<string, ZoneLayoutStack>();
+    for (const row of rows) {
+      let stack = stacks.get(row.stackId);
+      if (!stack) {
+        stack = {
+          stackId: row.stackId,
+          code: row.code,
+          name: row.name,
+          maxStackHeight: Number(row.maxStackHeight),
+          status: row.stackStatus,
+          isActive: row.stackIsActive,
+          slots: [],
+        };
+        stacks.set(row.stackId, stack);
+      }
+      if (row.slotId) {
+        stack.slots.push({
+          slotId: row.slotId,
+          level: Number(row.level),
+          effectiveStatus: this.effectiveStatus(row.slotStatus, row.slotIsActive, row.inventoryId),
+          inventoryId: row.inventoryId,
+          containerNumber: row.containerNumber,
+        });
+      }
+    }
+
+    return {
+      zoneId: zone.id,
+      zoneCode: zone.code,
+      zoneName: zone.name,
+      stacks: [...stacks.values()],
+      summary: await this.slotSummary({ zoneId }, manager),
+    };
+  }
+
+  private effectiveStatus(
+    status: string | null,
+    isActive: boolean | null,
+    inventoryId: string | null,
+  ): SlotEffectiveStatus {
+    if (inventoryId) return 'OCCUPIED';
+    if (isActive === false) return 'INACTIVE';
+    return (status as SlotEffectiveStatus) ?? 'AVAILABLE';
+  }
+
+  /**
+   * The three numbers that are routinely confused: what was configured, what is
+   * physically built, and what is actually full. Configured capacity is never
+   * overwritten from the slot count — a mismatch is reported, not corrected.
+   */
+  async slotSummary(
+    scope: { zoneId?: string; yardId?: string },
+    manager?: EntityManager,
+  ): Promise<SlotSummary> {
+    if (!scope.zoneId && !scope.yardId) {
+      throw new BadRequestException('A zone or yard is required');
+    }
+
+    const [row] = await this.em(manager).query(
+      `SELECT
+         (SELECT SUM(z.capacity_containers)
+            FROM freight.warehouse_zones z
+           WHERE z.deleted_at IS NULL
+             AND ($1::uuid IS NULL OR z.id = $1::uuid)
+             AND ($2::uuid IS NULL OR z.yard_id = $2::uuid)) AS "configuredCapacity",
+         COUNT(sl.id) AS "physicalSlotCount",
+         COUNT(i.id) AS "occupiedSlotCount",
+         COUNT(*) FILTER (WHERE i.id IS NULL AND sl.is_active AND sl.status = 'RESERVED') AS "reservedSlotCount",
+         COUNT(*) FILTER (WHERE i.id IS NULL AND sl.is_active AND sl.status = 'BLOCKED') AS "blockedSlotCount",
+         COUNT(*) FILTER (WHERE sl.id IS NOT NULL AND (NOT sl.is_active OR sl.status = 'INACTIVE'))
+           AS "inactiveSlotCount",
+         COUNT(*) FILTER (WHERE i.id IS NULL AND sl.is_active AND sl.status = 'AVAILABLE'
+                            AND s.status = 'ACTIVE' AND s.is_active) AS "availableSlotCount"
+       FROM freight.warehouse_zones z
+       JOIN freight.warehouse_zone_stacks s ON s.zone_id = z.id AND s.deleted_at IS NULL
+       LEFT JOIN freight.warehouse_zone_slots sl ON sl.stack_id = s.id AND sl.deleted_at IS NULL
+       LEFT JOIN freight.warehouse_inventory i
+              ON i.slot_id = sl.id AND i.deleted_at IS NULL AND i.status = ANY($3)
+       WHERE z.deleted_at IS NULL
+         AND ($1::uuid IS NULL OR z.id = $1::uuid)
+         AND ($2::uuid IS NULL OR z.yard_id = $2::uuid)`,
+      [scope.zoneId ?? null, scope.yardId ?? null, OCCUPYING],
+    );
+
+    const configuredCapacity = row?.configuredCapacity == null ? null : Number(row.configuredCapacity);
+    const physicalSlotCount = Number(row?.physicalSlotCount ?? 0);
+
+    return {
+      configuredCapacity,
+      physicalSlotCount,
+      occupiedSlotCount: Number(row?.occupiedSlotCount ?? 0),
+      reservedSlotCount: Number(row?.reservedSlotCount ?? 0),
+      blockedSlotCount: Number(row?.blockedSlotCount ?? 0),
+      inactiveSlotCount: Number(row?.inactiveSlotCount ?? 0),
+      availableSlotCount: Number(row?.availableSlotCount ?? 0),
+      inconsistent: configuredCapacity != null && physicalSlotCount > configuredCapacity,
+    };
+  }
+
+  /** Free a slot explicitly. Exit paths don't need this — status alone frees it. */
+  async releaseSlot(inventoryId: string, manager?: EntityManager): Promise<void> {
+    await this.em(manager).query(
+      `UPDATE freight.warehouse_inventory
+          SET stack_id = NULL, slot_id = NULL, updated_at = now()
+        WHERE id = $1 AND deleted_at IS NULL`,
+      [inventoryId],
+    );
+  }
+
+  /** Write a validated placement onto an inventory row inside the caller's transaction. */
+  async applyPlacement(
+    manager: EntityManager,
+    inventoryId: string,
+    placement: { stackId: string; slotId: string } | null,
+  ): Promise<void> {
+    await manager.getRepository(WarehouseInventory).update(inventoryId, {
+      stackId: placement?.stackId ?? null,
+      slotId: placement?.slotId ?? null,
+    });
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
index 7e658d9db..c51002a5a 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.controller.ts
@@ -1,4 +1,4 @@
-import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, ParseUUIDPipe, Patch, Post } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
 import { BookingStaff } from '../../common/booking-guards';
@@ -40,6 +40,16 @@ export class WarehouseYardsController {
     return this.yardsService.update(id, dto);
   }
 
+  @Delete(':id')
+  @BookingStaff(FREIGHT_PERMS.warehouseYards.delete)
+  @ApiOperation({
+    summary: 'Delete warehouse yard',
+    description: 'Soft-deletes the yard. Refused while it still has zones.',
+  })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.yardsService.remove(id);
+  }
+
   @Get(':yardId/zones')
   @BookingStaff(FREIGHT_PERMS.warehouseZones.view)
   @ApiOperation({ summary: 'List zones within a yard' })
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.service.ts
index 874de75db..b9e212ae1 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-yards.service.ts
@@ -107,6 +107,24 @@ export class WarehouseYardsService {
     return this.findById(id);
   }
 
+  /**
+   * Soft-delete a yard. Zones (and the inventory sitting in them) are left
+   * alone — a yard still holding zones is refused rather than orphaning stock.
+   */
+  async remove(id: string): Promise<{ id: string; deleted: true }> {
+    const existing = await this.findById(id);
+
+    if (existing.zones?.length) {
+      throw new ConflictException(
+        `Yard ${existing.code} still has ${existing.zones.length} zone(s). Delete them first.`,
+      );
+    }
+
+    await this.yardsRepository.softDelete(id);
+
+    return { id, deleted: true };
+  }
+
   private async assertCodeUnique(warehouseId: string, code: string, ignoreId?: string): Promise<void> {
     const [existing] = await this.yardsRepository.findAll({ where: { warehouseId, code } });
 
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-slots.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-slots.repository.ts
new file mode 100644
index 000000000..f24bcfc33
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-slots.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseZoneSlot } from './entities/warehouse-zone-slot.entity';
+
+@Injectable()
+export class WarehouseZoneSlotsRepository extends BaseRepository<WarehouseZoneSlot> {
+  constructor(@InjectRepository(WarehouseZoneSlot) repository: Repository<WarehouseZoneSlot>) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-stacks.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-stacks.controller.ts
new file mode 100644
index 000000000..17ce778d0
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-stacks.controller.ts
@@ -0,0 +1,102 @@
+import {
+  BadRequestException,
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+
+import { BookingStaff } from '../../common/booking-guards';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
+import {
+  CreateWarehouseZoneStackDto,
+  UpdateWarehouseZoneSlotDto,
+  UpdateWarehouseZoneStackDto,
+} from './dto/warehouse-zone-stack.dto';
+import { WarehouseZoneStacksService } from './warehouse-zone-stacks.service';
+
+/**
+ * Stacks and slots are zone configuration, so they ride the warehouse-zone
+ * permissions rather than introducing new keys — a new key needs a matching
+ * `iam.permissions` row in every environment or boot fails.
+ */
+@ApiTags('warehouse-zone-stacks')
+@ApiBearerAuth()
+@Controller('warehouse-zone-stacks')
+// Class gate lists every key its routes use: Nest runs class AND method guards.
+@BookingStaff([
+  FREIGHT_PERMS.warehouseZones.view,
+  FREIGHT_PERMS.warehouseInventory.view,
+  FREIGHT_PERMS.warehouseZones.create,
+  FREIGHT_PERMS.warehouseZones.update,
+  FREIGHT_PERMS.warehouseZones.delete,
+])
+export class WarehouseZoneStacksController {
+  constructor(private readonly stacksService: WarehouseZoneStacksService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'List the ground stacks configured in a zone' })
+  findByZone(@Query('zoneId', ParseUUIDPipe) zoneId: string) {
+    return this.stacksService.findByZone(zoneId);
+  }
+
+  @Post()
+  @BookingStaff(FREIGHT_PERMS.warehouseZones.create)
+  @ApiOperation({
+    summary: 'Create a ground stack',
+    description: 'One slot per level is generated automatically, from 1 to maxStackHeight (default 3).',
+  })
+  create(@Body() dto: CreateWarehouseZoneStackDto, @Query('zoneId') zoneIdQuery?: string) {
+    const zoneId = dto.zoneId ?? zoneIdQuery;
+    if (!zoneId) {
+      throw new BadRequestException('zoneId is required');
+    }
+    return this.stacksService.create(zoneId, dto);
+  }
+
+  // Declared before ':id' so 'slots' is never swallowed as a stack id.
+  @Patch('slots/:slotId')
+  @BookingStaff(FREIGHT_PERMS.warehouseZones.update)
+  @ApiOperation({
+    summary: 'Block, reserve, or reactivate one slot',
+    description: 'Occupancy is derived from inventory and cannot be set here.',
+  })
+  updateSlot(@Param('slotId', ParseUUIDPipe) slotId: string, @Body() dto: UpdateWarehouseZoneSlotDto) {
+    return this.stacksService.updateSlot(slotId, dto);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Get one stack with its slots' })
+  findOne(@Param('id', ParseUUIDPipe) id: string) {
+    return this.stacksService.findById(id);
+  }
+
+  @Get(':id/occupancy')
+  @ApiOperation({ summary: 'Level-by-level occupancy of one stack' })
+  occupancy(@Param('id', ParseUUIDPipe) id: string) {
+    return this.stacksService.slotOccupancy(id);
+  }
+
+  @Patch(':id')
+  @BookingStaff(FREIGHT_PERMS.warehouseZones.update)
+  @ApiOperation({
+    summary: 'Update a stack',
+    description: 'Raising maxStackHeight adds slots; lowering it trims the empty top levels.',
+  })
+  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateWarehouseZoneStackDto) {
+    return this.stacksService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @BookingStaff(FREIGHT_PERMS.warehouseZones.delete)
+  @ApiOperation({ summary: 'Delete a stack', description: 'Refused while containers still stand in it.' })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.stacksService.remove(id);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-stacks.repository.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-stacks.repository.ts
new file mode 100644
index 000000000..92a798ec1
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-stacks.repository.ts
@@ -0,0 +1,13 @@
+import { BaseRepository } from '@edr/api-common';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+
+import { WarehouseZoneStack } from './entities/warehouse-zone-stack.entity';
+
+@Injectable()
+export class WarehouseZoneStacksRepository extends BaseRepository<WarehouseZoneStack> {
+  constructor(@InjectRepository(WarehouseZoneStack) repository: Repository<WarehouseZoneStack>) {
+    super(repository);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-stacks.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-stacks.service.ts
new file mode 100644
index 000000000..b74116c7a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zone-stacks.service.ts
@@ -0,0 +1,245 @@
+import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { DataSource, EntityManager, In, IsNull } from 'typeorm';
+
+import {
+  CreateWarehouseZoneStackDto,
+  UpdateWarehouseZoneSlotDto,
+  UpdateWarehouseZoneStackDto,
+} from './dto/warehouse-zone-stack.dto';
+import {
+  DEFAULT_MAX_STACK_HEIGHT,
+  WarehouseZoneStack,
+} from './entities/warehouse-zone-stack.entity';
+import { WarehouseZoneSlot } from './entities/warehouse-zone-slot.entity';
+import { WarehousePlacementService } from './warehouse-placement.service';
+import { WarehouseZoneSlotsRepository } from './warehouse-zone-slots.repository';
+import { WarehouseZoneStacksRepository } from './warehouse-zone-stacks.repository';
+import { WarehouseZonesService } from './warehouse-zones.service';
+
+/**
+ * Ground stacks and their vertical slots — the physical layout of a zone.
+ *
+ * Slots are never created by hand: a stack of height 3 is three slots, so they
+ * are generated with the stack and kept in step with its height. That is the
+ * only way the placement engine can trust `level` to mean what it says.
+ */
+@Injectable()
+export class WarehouseZoneStacksService {
+  constructor(
+    private readonly stacksRepository: WarehouseZoneStacksRepository,
+    private readonly slotsRepository: WarehouseZoneSlotsRepository,
+    private readonly zonesService: WarehouseZonesService,
+    private readonly placement: WarehousePlacementService,
+    @InjectDataSource() private readonly dataSource: DataSource,
+  ) {}
+
+  findByZone(zoneId: string): Promise<WarehouseZoneStack[]> {
+    return this.stacksRepository.findAll({
+      where: { zoneId },
+      relations: { slots: true },
+      order: { code: 'ASC' },
+    });
+  }
+
+  async findById(id: string): Promise<WarehouseZoneStack> {
+    const stack = await this.stacksRepository.findById(id, { relations: { slots: true, zone: true } });
+    if (!stack) throw new NotFoundException(`Warehouse zone stack ${id} not found`);
+    stack.slots?.sort((a, b) => a.level - b.level);
+    return stack;
+  }
+
+  /** Create the stack and its slots together — a stack with no slots holds nothing. */
+  async create(zoneId: string, dto: CreateWarehouseZoneStackDto): Promise<WarehouseZoneStack> {
+    await this.zonesService.findById(zoneId);
+    const code = dto.code.trim();
+    await this.assertCodeUnique(zoneId, code);
+
+    const maxStackHeight = dto.maxStackHeight ?? DEFAULT_MAX_STACK_HEIGHT;
+
+    const id = await this.dataSource.transaction(async (manager) => {
+      const stack = await manager.getRepository(WarehouseZoneStack).save(
+        manager.getRepository(WarehouseZoneStack).create({
+          zoneId,
+          code,
+          name: dto.name?.trim() ?? null,
+          row: dto.row?.trim() ?? null,
+          bay: dto.bay?.trim() ?? null,
+          position: dto.position?.trim() ?? null,
+          maxStackHeight,
+          status: 'ACTIVE',
+          isActive: true,
+        }),
+      );
+
+      await this.generateSlots(manager, stack.id, 1, maxStackHeight);
+      return stack.id;
+    });
+
+    return this.findById(id);
+  }
+
+  async update(id: string, dto: UpdateWarehouseZoneStackDto): Promise<WarehouseZoneStack> {
+    const existing = await this.findById(id);
+    const code = dto.code?.trim() ?? existing.code;
+
+    if (code !== existing.code) {
+      await this.assertCodeUnique(existing.zoneId, code, id);
+    }
+
+    const newHeight = dto.maxStackHeight ?? existing.maxStackHeight;
+    const status = dto.status ?? existing.status;
+
+    if (status === 'INACTIVE' && existing.status !== 'INACTIVE') {
+      await this.assertStackEmpty(id, 'deactivated');
+    }
+
+    await this.dataSource.transaction(async (manager) => {
+      if (newHeight > existing.maxStackHeight) {
+        await this.generateSlots(manager, id, existing.maxStackHeight + 1, newHeight);
+      } else if (newHeight < existing.maxStackHeight) {
+        await this.removeSlotsAbove(manager, id, newHeight, existing.code);
+      }
+
+      await manager.getRepository(WarehouseZoneStack).update(id, {
+        code,
+        name: dto.name?.trim() ?? existing.name,
+        row: dto.row?.trim() ?? existing.row,
+        bay: dto.bay?.trim() ?? existing.bay,
+        position: dto.position?.trim() ?? existing.position,
+        maxStackHeight: newHeight,
+        status,
+        isActive: status === 'ACTIVE',
+      });
+    });
+
+    return this.findById(id);
+  }
+
+  /**
+   * Soft-delete a stack. Refused while anything stands in it — the boxes would
+   * be left pointing at a position every layout query drops.
+   */
+  async remove(id: string): Promise<{ id: string; deleted: true }> {
+    const existing = await this.findById(id);
+    await this.assertStackEmpty(id, 'deleted');
+
+    await this.dataSource.transaction(async (manager) => {
+      await manager.getRepository(WarehouseZoneSlot).softDelete({ stackId: id });
+      await manager.getRepository(WarehouseZoneStack).softDelete(id);
+    });
+
+    return { id: existing.id, deleted: true };
+  }
+
+  /**
+   * Set operator intent on one slot. OCCUPIED is not settable — it is derived
+   * from the inventory sitting there — and a slot holding a box cannot be
+   * blocked or switched off underneath it.
+   */
+  async updateSlot(slotId: string, dto: UpdateWarehouseZoneSlotDto): Promise<WarehouseZoneSlot> {
+    const slot = await this.slotsRepository.findById(slotId);
+    if (!slot) throw new NotFoundException(`Warehouse zone slot ${slotId} not found`);
+
+    const status = dto.status ?? slot.status;
+    const isActive = dto.isActive ?? (dto.status ? dto.status !== 'INACTIVE' : slot.isActive);
+    const closingOff = status === 'BLOCKED' || status === 'INACTIVE' || isActive === false;
+
+    if (closingOff) {
+      const [held] = await this.dataSource.query(
+        `SELECT i.id FROM freight.warehouse_inventory i
+          WHERE i.slot_id = $1 AND i.deleted_at IS NULL
+            AND i.status IN ('UNLOADED','RECEIVED','STORED','RESERVED','READY_FOR_LOADING','READY_FOR_PICKUP')
+          LIMIT 1`,
+        [slotId],
+      );
+      if (held) {
+        throw new ConflictException('Slot still holds a container. Move it out first.');
+      }
+    }
+
+    const updated = await this.slotsRepository.update(slotId, { status, isActive });
+    if (!updated) throw new NotFoundException(`Warehouse zone slot ${slotId} not found`);
+    return updated;
+  }
+
+  /** Occupancy of one stack, level by level. */
+  async slotOccupancy(stackId: string): Promise<
+    Array<{ slotId: string; level: number; effectiveStatus: string; inventoryId: string | null }>
+  > {
+    const stack = await this.findById(stackId);
+    const layout = await this.placement.zoneLayout(stack.zoneId);
+    const found = layout.stacks.find((s) => s.stackId === stackId);
+    return (found?.slots ?? []).map((s) => ({
+      slotId: s.slotId,
+      level: s.level,
+      effectiveStatus: s.effectiveStatus,
+      inventoryId: s.inventoryId,
+    }));
+  }
+
+  // ── internals ─────────────────────────────────────────────────────────────
+
+  /** Idempotent: a level that already exists (e.g. after a height cut and re-raise) is skipped. */
+  private async generateSlots(
+    manager: EntityManager,
+    stackId: string,
+    fromLevel: number,
+    toLevel: number,
+  ): Promise<void> {
+    const repository = manager.getRepository(WarehouseZoneSlot);
+    const existing = await repository.find({ where: { stackId }, withDeleted: true });
+    const byLevel = new Map(existing.map((slot) => [slot.level, slot]));
+
+    for (let level = fromLevel; level <= toLevel; level += 1) {
+      const found = byLevel.get(level);
+      if (found?.deletedAt) {
+        // Bring a previously trimmed level back rather than colliding with the
+        // (stack_id, level) unique index.
+        await repository.restore(found.id);
+        await repository.update(found.id, { status: 'AVAILABLE', isActive: true });
+      } else if (!found) {
+        await repository.save(repository.create({ stackId, level, status: 'AVAILABLE', isActive: true }));
+      }
+    }
+  }
+
+  private async removeSlotsAbove(
+    manager: EntityManager,
+    stackId: string,
+    newHeight: number,
+    stackCode: string,
+  ): Promise<void> {
+    const occupied = await this.placement.occupiedLevels(stackId, null, manager);
+    const stillUsed = occupied.filter((level) => level > newHeight);
+    if (stillUsed.length > 0) {
+      throw new BadRequestException(
+        `Stack ${stackCode}: level(s) ${stillUsed.join(', ')} still hold containers — cannot lower the height to ${newHeight}`,
+      );
+    }
+
+    const doomed = await manager.getRepository(WarehouseZoneSlot).find({
+      where: { stackId, deletedAt: IsNull() },
+    });
+    const ids = doomed.filter((slot) => slot.level > newHeight).map((slot) => slot.id);
+    if (ids.length > 0) {
+      await manager.getRepository(WarehouseZoneSlot).softDelete({ id: In(ids) });
+    }
+  }
+
+  private async assertStackEmpty(stackId: string, action: string): Promise<void> {
+    const occupied = await this.placement.occupiedLevels(stackId);
+    if (occupied.length > 0) {
+      throw new ConflictException(
+        `Stack still holds ${occupied.length} container(s) at level(s) ${occupied.join(', ')}. Move them out before it can be ${action}.`,
+      );
+    }
+  }
+
+  private async assertCodeUnique(zoneId: string, code: string, ignoreId?: string): Promise<void> {
+    const [existing] = await this.stacksRepository.findAll({ where: { zoneId, code } });
+    if (existing && existing.id !== ignoreId) {
+      throw new ConflictException(`Stack code ${code} already exists in this zone`);
+    }
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.controller.ts
index 04cbacd28..c88b8d3d6 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.controller.ts
@@ -1,4 +1,4 @@
-import { Body, Controller, Get, Param, ParseUUIDPipe, Patch } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, ParseUUIDPipe, Patch } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
 import { BookingStaff } from '../../common/booking-guards';
@@ -18,6 +18,7 @@ import { WarehouseZonesService } from './warehouse-zones.service';
   FREIGHT_PERMS.warehouseZones.view,
   FREIGHT_PERMS.warehouseInventory.view,
   FREIGHT_PERMS.warehouseZones.update,
+  FREIGHT_PERMS.warehouseZones.delete,
 ])
 export class WarehouseZonesController {
   constructor(private readonly zonesService: WarehouseZonesService) {}
@@ -40,4 +41,41 @@ export class WarehouseZonesController {
   update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateWarehouseZoneDto) {
     return this.zonesService.update(id, dto);
   }
+
+  @Get(':id/contents')
+  @ApiOperation({
+    summary: 'What is currently stored in a zone',
+    description: 'A row per container — booked units and backlog-registered containers alike.',
+  })
+  contents(@Param('id', ParseUUIDPipe) id: string) {
+    return this.zonesService.contents(id);
+  }
+
+  @Get(':id/layout')
+  @ApiOperation({
+    summary: 'Physical layout of a zone',
+    description: 'Every ground stack with its levels, what stands on each, and the slot summary.',
+  })
+  layout(@Param('id', ParseUUIDPipe) id: string) {
+    return this.zonesService.layout(id);
+  }
+
+  @Get(':id/slot-summary')
+  @ApiOperation({
+    summary: 'Configured capacity vs physical slots vs occupancy',
+    description: 'Flags a zone whose built slots exceed its configured container capacity.',
+  })
+  slotSummary(@Param('id', ParseUUIDPipe) id: string) {
+    return this.zonesService.slotSummary(id);
+  }
+
+  @Delete(':id')
+  @BookingStaff(FREIGHT_PERMS.warehouseZones.delete)
+  @ApiOperation({
+    summary: 'Delete warehouse zone',
+    description: 'Soft-deletes the zone. Refused while inventory still sits in it.',
+  })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.zonesService.remove(id);
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.service.ts
index 367a5a75e..78011a369 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouse-zones.service.ts
@@ -1,16 +1,35 @@
 import { BadRequestException, ConflictException, Injectable, NotFoundException } from '@nestjs/common';
+import { InjectDataSource } from '@nestjs/typeorm';
+import { DataSource } from 'typeorm';
 
 import { CreateWarehouseZoneDto } from './dto/create-warehouse-zone.dto';
 import { UpdateWarehouseZoneDto } from './dto/update-warehouse-zone.dto';
 import { WarehouseZone } from './entities/warehouse-zone.entity';
+import { WarehouseInventoryRepository } from './warehouse-inventory.repository';
+import { WarehousePlacementService } from './warehouse-placement.service';
 import { WarehouseYardsService } from './warehouse-yards.service';
 import { WarehouseZonesRepository } from './warehouse-zones.repository';
 
+/** One container (or one bulk lot) currently sitting in a zone. */
+export interface ZoneContentItem {
+  inventoryId: string;
+  containerNumber: string | null;
+  unloadedAt: string | null;
+  containerType: string | null;
+  direction: 'IMPORT' | 'EXPORT' | null;
+  loadState: string | null;
+  status: string;
+  bookingReference: string | null;
+}
+
 @Injectable()
 export class WarehouseZonesService {
   constructor(
     private readonly zonesRepository: WarehouseZonesRepository,
     private readonly yardsService: WarehouseYardsService,
+    private readonly inventoryRepository: WarehouseInventoryRepository,
+    private readonly placement: WarehousePlacementService,
+    @InjectDataSource() private readonly dataSource: DataSource,
   ) {}
 
   findAll(): Promise<WarehouseZone[]> {
@@ -98,6 +117,94 @@ export class WarehouseZonesService {
     return this.findById(id);
   }
 
+  /**
+   * What is physically sitting in one zone, a row per container.
+   *
+   * Container identity has two sources and neither covers the other: booked
+   * cargo carries its units on `booking_container_units`, while a backlog
+   * registration has no booking and links `warehouse_inventory.container_id`
+   * straight to a `containers` row. Bulk cargo has neither, so it comes back
+   * with a null container number rather than being dropped from its zone.
+   *
+   * Full/empty likewise: `containers.status` when there is a container row,
+   * otherwise a returned unit is the empty one.
+   */
+  async contents(zoneId: string): Promise<ZoneContentItem[]> {
+    await this.findById(zoneId);
+
+    return this.dataSource.query(
+      `SELECT i.id AS "inventoryId",
+              COALESCE(c.container_number, bcu.container_number) AS "containerNumber",
+              i.unloaded_at AS "unloadedAt",
+              COALESCE(ct_direct.label, ct_booked.label, bc.container_size) AS "containerType",
+              b.trade_direction AS "direction",
+              CASE
+                WHEN c.status IS NOT NULL THEN c.status
+                WHEN bcu.is_return THEN 'EMPTY'
+                WHEN bcu.container_number IS NOT NULL THEN 'FULL'
+                ELSE NULL
+              END AS "loadState",
+              i.status AS "status",
+              b.reference AS "bookingReference"
+         FROM freight.warehouse_inventory i
+         LEFT JOIN freight.containers c ON c.id = i.container_id AND c.deleted_at IS NULL
+         LEFT JOIN freight.container_types ct_direct ON ct_direct.id = c.container_type_id
+         LEFT JOIN freight.bookings b ON b.id = i.booking_id AND b.deleted_at IS NULL
+         LEFT JOIN freight.booking_container bc ON bc.booking_id = b.id AND bc.deleted_at IS NULL
+         LEFT JOIN freight.container_types ct_booked ON ct_booked.id = bc.container_type_id
+         LEFT JOIN freight.booking_container_units bcu
+                ON bcu.booking_container_id = bc.id AND bcu.deleted_at IS NULL
+        WHERE i.zone_id = $1 AND i.deleted_at IS NULL
+        ORDER BY i.unloaded_at DESC NULLS LAST,
+                 COALESCE(c.container_number, bcu.container_number)`,
+      [zoneId],
+    );
+  }
+
+  /** The zone's physical layout: every ground stack, every level, what stands there. */
+  async layout(zoneId: string) {
+    await this.findById(zoneId);
+    return this.placement.zoneLayout(zoneId);
+  }
+
+  /** Configured capacity vs slots actually built vs slots actually full. */
+  async slotSummary(zoneId: string) {
+    await this.findById(zoneId);
+    return this.placement.slotSummary({ zoneId });
+  }
+
+  /**
+   * Soft-delete a zone. Inventory points at a zone, so a zone still holding
+   * stock is refused — soft-deleting it would leave those rows pointing at a
+   * location every zone-joining query drops. Configured stacks block it for the
+   * same reason: they would survive their parent and never be reachable again.
+   */
+  async remove(id: string): Promise<{ id: string; deleted: true }> {
+    const existing = await this.findById(id);
+    const [, held] = await this.inventoryRepository.findAndCount({ where: { zoneId: id } });
+
+    if (held > 0) {
+      throw new ConflictException(
+        `Zone ${existing.code} still holds ${held} inventory item(s). Move them out first.`,
+      );
+    }
+
+    const [stacks] = await this.dataSource.query(
+      `SELECT count(*)::int AS count FROM freight.warehouse_zone_stacks
+        WHERE zone_id = $1 AND deleted_at IS NULL`,
+      [id],
+    );
+    if (Number(stacks?.count ?? 0) > 0) {
+      throw new ConflictException(
+        `Zone ${existing.code} still has ${stacks.count} configured stack(s). Delete them first.`,
+      );
+    }
+
+    await this.zonesRepository.softDelete(id);
+
+    return { id, deleted: true };
+  }
+
   private async assertCodeUnique(yardId: string, code: string, ignoreId?: string): Promise<void> {
     const [existing] = await this.zonesRepository.findAll({ where: { yardId, code } });
 
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts
index 275afadf6..6a2a51b4e 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.controller.ts
@@ -1,4 +1,4 @@
-import { Body, Controller, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
+import { Body, Controller, Delete, Get, Param, ParseUUIDPipe, Patch, Post, Query } from '@nestjs/common';
 import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
 
 import { BookingStaff } from '../../common/booking-guards';
@@ -25,6 +25,7 @@ import { WarehousesService } from './warehouses.service';
   FREIGHT_PERMS.warehouseDashboard.view,
   FREIGHT_PERMS.warehouses.create,
   FREIGHT_PERMS.warehouses.update,
+  FREIGHT_PERMS.warehouses.delete,
   FREIGHT_PERMS.warehouseYards.view,
   FREIGHT_PERMS.warehouseYards.create,
 ])
@@ -79,6 +80,16 @@ export class WarehousesController {
     return this.warehousesService.update(id, dto);
   }
 
+  @Delete(':id')
+  @BookingStaff(FREIGHT_PERMS.warehouses.delete)
+  @ApiOperation({
+    summary: 'Delete warehouse',
+    description: 'Soft-deletes the warehouse. Refused while it still has yards.',
+  })
+  remove(@Param('id', ParseUUIDPipe) id: string) {
+    return this.warehousesService.remove(id);
+  }
+
   @Get(':warehouseId/yards')
   @BookingStaff(FREIGHT_PERMS.warehouseYards.view)
   @ApiOperation({ summary: 'List yards within a warehouse' })
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts
index d91ac2baf..48d787e55 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.module.ts
@@ -21,6 +21,8 @@ import { WarehouseInventoryMovement } from './entities/warehouse-inventory-movem
 import { WarehouseLoading } from './entities/warehouse-loading.entity';
 import { WarehouseYard } from './entities/warehouse-yard.entity';
 import { WarehouseZone } from './entities/warehouse-zone.entity';
+import { WarehouseZoneSlot } from './entities/warehouse-zone-slot.entity';
+import { WarehouseZoneStack } from './entities/warehouse-zone-stack.entity';
 import { Warehouse } from './entities/warehouse.entity';
 import { SchedulingReadFacade } from './scheduling-read.facade';
 import { WarehouseActivityLogRepository } from './warehouse-activity-log.repository';
@@ -47,6 +49,11 @@ import { WarehouseSchedulingAdapterService } from './warehouse-scheduling-adapte
 import { WarehouseYardsController } from './warehouse-yards.controller';
 import { WarehouseYardsRepository } from './warehouse-yards.repository';
 import { WarehouseYardsService } from './warehouse-yards.service';
+import { WarehousePlacementService } from './warehouse-placement.service';
+import { WarehouseZoneSlotsRepository } from './warehouse-zone-slots.repository';
+import { WarehouseZoneStacksController } from './warehouse-zone-stacks.controller';
+import { WarehouseZoneStacksRepository } from './warehouse-zone-stacks.repository';
+import { WarehouseZoneStacksService } from './warehouse-zone-stacks.service';
 import { WarehouseZonesController } from './warehouse-zones.controller';
 import { WarehouseZonesRepository } from './warehouse-zones.repository';
 import { WarehouseZonesService } from './warehouse-zones.service';
@@ -60,6 +67,8 @@ import { WarehousesService } from './warehouses.service';
       Warehouse,
       WarehouseYard,
       WarehouseZone,
+      WarehouseZoneStack,
+      WarehouseZoneSlot,
       WarehouseInventory,
       WarehouseInventoryMovement,
       WarehouseActivityLog,
@@ -83,6 +92,7 @@ import { WarehousesService } from './warehouses.service';
     WarehousesController,
     WarehouseYardsController,
     WarehouseZonesController,
+    WarehouseZoneStacksController,
     WarehouseInventoryController,
     WarehouseLoadingsController,
     WarehouseInspectionController,
@@ -93,6 +103,8 @@ import { WarehousesService } from './warehouses.service';
     WarehousesRepository,
     WarehouseYardsRepository,
     WarehouseZonesRepository,
+    WarehouseZoneStacksRepository,
+    WarehouseZoneSlotsRepository,
     WarehouseInventoryRepository,
     WarehouseInventoryMovementRepository,
     WarehouseActivityLogRepository,
@@ -103,6 +115,8 @@ import { WarehousesService } from './warehouses.service';
     WarehousesService,
     WarehouseYardsService,
     WarehouseZonesService,
+    WarehouseZoneStacksService,
+    WarehousePlacementService,
     WarehouseInventoryService,
     WarehouseActivityLogService,
     WarehouseDashboardService,
@@ -119,6 +133,8 @@ import { WarehousesService } from './warehouses.service';
     WarehousesService,
     WarehouseYardsService,
     WarehouseZonesService,
+    WarehouseZoneStacksService,
+    WarehousePlacementService,
     WarehouseInventoryService,
     WarehouseAllocationService,
     WarehouseFeeService,
diff --git a/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts b/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts
index 140d9f6b4..43284ca8f 100644
--- a/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts
+++ b/apps/edr-freight-api/src/modules/warehouses/warehouses.service.ts
@@ -54,6 +54,7 @@ export class WarehousesService {
         name: dto.name.trim(),
         code: dto.code.trim(),
         type: dto.type,
+        freightType: dto.freightType ?? null,
         stationId: dto.stationId ?? null,
         facilityId: dto.facilityId ?? null,
         locationName: dto.locationName?.trim() ?? null,
@@ -87,6 +88,7 @@ export class WarehousesService {
         name: dto.name?.trim() ?? existing.name,
         code: dto.code?.trim() ?? existing.code,
         type: dto.type ?? existing.type,
+        freightType: dto.freightType ?? existing.freightType,
         stationId: dto.stationId ?? existing.stationId,
         facilityId: dto.facilityId ?? existing.facilityId,
         locationName: dto.locationName?.trim() ?? existing.locationName,
@@ -108,6 +110,25 @@ export class WarehousesService {
     return this.findById(id);
   }
 
+  /**
+   * Soft-delete a warehouse. Yards (and therefore zones and inventory, which
+   * hang off a zone) are left alone — a warehouse holding them is refused
+   * rather than silently orphaning stock.
+   */
+  async remove(id: string): Promise<{ id: string; deleted: true }> {
+    const existing = await this.findById(id);
+
+    if (existing.yards?.length) {
+      throw new ConflictException(
+        `Warehouse ${existing.code} still has ${existing.yards.length} yard(s). Delete them first.`,
+      );
+    }
+
+    await this.warehousesRepository.softDelete(id);
+
+    return { id, deleted: true };
+  }
+
   /** Map low-level DB errors (FK / length / etc.) to a clean 400 instead of a 500. */
   private mapDbError(error: unknown): never {
     if (error instanceof QueryFailedError) {
diff --git a/apps/edr-freight-api/src/scripts/seed-warehouse-layout.ts b/apps/edr-freight-api/src/scripts/seed-warehouse-layout.ts
new file mode 100644
index 000000000..d0872a6bb
--- /dev/null
+++ b/apps/edr-freight-api/src/scripts/seed-warehouse-layout.ts
@@ -0,0 +1,35 @@
+import { AppDataSource } from '../data-source';
+import { WarehouseLayoutSeeder } from '../seed/warehouse-layout.seeder';
+
+/**
+ * Lays out the physical warehouse structure described by
+ * `src/seed/warehouse-layout.json` — edit that file, not this script.
+ *
+ * Idempotent: existing warehouses, yards, zones, stacks and slots are left
+ * untouched, so a re-run only fills in what is missing.
+ */
+async function seedWarehouseLayout() {
+  await AppDataSource.initialize();
+
+  try {
+    const summary = await new WarehouseLayoutSeeder(AppDataSource).run();
+    console.table([summary]);
+
+    const counts = await AppDataSource.query(`
+      SELECT
+        (SELECT COUNT(*)::int FROM freight.warehouses WHERE deleted_at IS NULL) AS warehouses,
+        (SELECT COUNT(*)::int FROM freight.warehouse_yards WHERE deleted_at IS NULL) AS yards,
+        (SELECT COUNT(*)::int FROM freight.warehouse_zones WHERE deleted_at IS NULL) AS zones,
+        (SELECT COUNT(*)::int FROM freight.warehouse_zone_stacks WHERE deleted_at IS NULL) AS stacks,
+        (SELECT COUNT(*)::int FROM freight.warehouse_zone_slots WHERE deleted_at IS NULL) AS slots
+    `);
+    console.table(counts);
+  } finally {
+    await AppDataSource.destroy();
+  }
+}
+
+seedWarehouseLayout().catch((error) => {
+  console.error('Failed to seed the warehouse layout:', error);
+  process.exit(1);
+});
diff --git a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
index ac2507aa5..bb83518df 100644
--- a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
+++ b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
@@ -1272,6 +1272,11 @@ export const WAREHOUSE_PERMISSIONS: FreightPermissionSeed[] = [
     "edr_freight_app:warehouse_zones:update",
     "Update warehouse zone",
   ),
+  perm(
+    "f1c00001-0001-4000-8000-000000000004",
+    "edr_freight_app:warehouse_zones:delete",
+    "Delete warehouse zone",
+  ),
   perm(
     "f1d00001-0001-4000-8000-000000000001",
     "edr_freight_app:warehouse_allocation_rules:view",
@@ -2307,6 +2312,7 @@ export const FREIGHT_PERMS = {
     view: "edr_freight_app:warehouse_zones:view",
     create: "edr_freight_app:warehouse_zones:create",
     update: "edr_freight_app:warehouse_zones:update",
+    delete: "edr_freight_app:warehouse_zones:delete",
   },
   warehouseAllocationRules: {
     view: "edr_freight_app:warehouse_allocation_rules:view",
diff --git a/apps/edr-freight-api/src/seed/warehouse-layout.json b/apps/edr-freight-api/src/seed/warehouse-layout.json
new file mode 100644
index 000000000..5563bf112
--- /dev/null
+++ b/apps/edr-freight-api/src/seed/warehouse-layout.json
@@ -0,0 +1,28 @@
+{
+  "facility": {
+    "code": "GELAN",
+    "name": "Gelan Dry Port",
+    "facilityType": "DRY_PORT"
+  },
+  "levels": ["L1", "L2", "L3", "L4"],
+  "kinds": [
+    { "suffix": "OPEN", "letter": "O", "name": "Open Warehouse", "type": "OPEN_WAREHOUSE" },
+    { "suffix": "CLOSED", "letter": "C", "name": "Closed Warehouse", "type": "CLOSED_WAREHOUSE" }
+  ],
+  "yards": [
+    { "label": "A", "type": "CONTAINER_YARD", "capacityContainers": 150 },
+    { "label": "B", "type": "CONTAINER_YARD", "capacityContainers": 150 },
+    { "label": "C", "type": "GENERAL_CARGO_YARD", "capacityContainers": null },
+    { "label": "D", "type": "BULK_YARD", "capacityContainers": null },
+    { "label": "E", "type": "HAZARDOUS_YARD", "capacityContainers": null },
+    { "label": "F", "type": "COLD_STORAGE_YARD", "capacityContainers": null }
+  ],
+  "zones": [
+    { "label": "A", "capacityContainers": 60 },
+    { "label": "B", "capacityContainers": 45 },
+    { "label": "C", "capacityContainers": 45 }
+  ],
+  "stack": {
+    "maxStackHeight": 3
+  }
+}
diff --git a/apps/edr-freight-api/src/seed/warehouse-layout.seeder.ts b/apps/edr-freight-api/src/seed/warehouse-layout.seeder.ts
new file mode 100644
index 000000000..e7533592e
--- /dev/null
+++ b/apps/edr-freight-api/src/seed/warehouse-layout.seeder.ts
@@ -0,0 +1,214 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { DataSource } from 'typeorm';
+
+/**
+ * Builds the physical warehouse layout from `warehouse-layout.json`:
+ * facility → warehouses (L1-OPEN …) → yards (A–F) → zones (A–C) → ground
+ * stacks → slots.
+ *
+ * The shape is configuration, never enums: yard letters, zone letters and
+ * stack heights all come from the JSON, because a physical layout changes and
+ * a deployed enum does not.
+ *
+ * Idempotent on every code. A row that already exists is left exactly as it
+ * is — capacities tuned by hand on a live site must survive a re-run.
+ */
+export interface WarehouseLayoutConfig {
+  facility: { code: string; name: string; facilityType: string };
+  levels: string[];
+  kinds: Array<{ suffix: string; letter: string; name: string; type: string }>;
+  yards: Array<{ label: string; type: string; capacityContainers: number | null }>;
+  zones: Array<{ label: string; capacityContainers: number }>;
+  stack: { maxStackHeight: number };
+}
+
+export interface LayoutSeedSummary {
+  facilityCode: string;
+  warehousesCreated: number;
+  yardsCreated: number;
+  zonesCreated: number;
+  stacksCreated: number;
+  slotsCreated: number;
+}
+
+export class WarehouseLayoutSeeder {
+  constructor(
+    private readonly dataSource: DataSource,
+    private readonly config: WarehouseLayoutConfig = WarehouseLayoutSeeder.loadConfig(),
+  ) {}
+
+  static loadConfig(path = join(__dirname, 'warehouse-layout.json')): WarehouseLayoutConfig {
+    return JSON.parse(readFileSync(path, 'utf8')) as WarehouseLayoutConfig;
+  }
+
+  async run(): Promise<LayoutSeedSummary> {
+    const summary: LayoutSeedSummary = {
+      facilityCode: this.config.facility.code,
+      warehousesCreated: 0,
+      yardsCreated: 0,
+      zonesCreated: 0,
+      stacksCreated: 0,
+      slotsCreated: 0,
+    };
+
+    const facilityId = await this.upsertFacility();
+
+    for (const level of this.config.levels) {
+      for (const kind of this.config.kinds) {
+        const warehouseCode = `${level}-${kind.suffix}`;
+        const warehouse = await this.upsertWarehouse(facilityId, warehouseCode, `${level} ${kind.name}`, kind.type);
+        summary.warehousesCreated += warehouse.created ? 1 : 0;
+
+        for (const yardCfg of this.config.yards) {
+          const yardCode = `${level}-${kind.letter}-${yardCfg.label}`;
+          const yard = await this.upsertYard(warehouse.id, yardCode, `Yard ${yardCfg.label}`, yardCfg);
+          summary.yardsCreated += yard.created ? 1 : 0;
+
+          // Zones, stacks and slots are only laid out for container yards —
+          // bulk and general cargo do not stand in numbered positions.
+          if (yardCfg.type !== 'CONTAINER_YARD') continue;
+
+          for (const zoneCfg of this.config.zones) {
+            const zoneCode = `${yardCode}-Z${zoneCfg.label}`;
+            const zone = await this.upsertZone(yard.id, zoneCode, `Zone ${zoneCfg.label}`, zoneCfg.capacityContainers);
+            summary.zonesCreated += zone.created ? 1 : 0;
+
+            const height = this.config.stack.maxStackHeight;
+            // Ground positions, not boxes: a 60-container zone stacked three
+            // high needs 20 patches of concrete.
+            const stackCount = Math.floor(zoneCfg.capacityContainers / height);
+
+            for (let n = 1; n <= stackCount; n += 1) {
+              const stackCode = `Z${zoneCfg.label}-${String(n).padStart(3, '0')}`;
+              const stack = await this.upsertStack(zone.id, stackCode, height);
+              summary.stacksCreated += stack.created ? 1 : 0;
+              summary.slotsCreated += await this.upsertSlots(stack.id, height);
+            }
+          }
+        }
+      }
+    }
+
+    return summary;
+  }
+
+  private async upsertFacility(): Promise<string> {
+    const { code, name, facilityType } = this.config.facility;
+    const [existing] = await this.dataSource.query(
+      `SELECT id FROM freight.facilities WHERE code = $1 AND deleted_at IS NULL`,
+      [code],
+    );
+    if (existing) return existing.id;
+
+    const [created] = await this.dataSource.query(
+      `INSERT INTO freight.facilities (code, name, facility_type, facility_status, is_active)
+       VALUES ($1, $2, $3, 'ACTIVE', true)
+       RETURNING id`,
+      [code, name, facilityType],
+    );
+    return created.id;
+  }
+
+  private async upsertWarehouse(
+    facilityId: string,
+    code: string,
+    name: string,
+    type: string,
+  ): Promise<{ id: string; created: boolean }> {
+    const [existing] = await this.dataSource.query(
+      `SELECT id FROM freight.warehouses WHERE code = $1 AND deleted_at IS NULL`,
+      [code],
+    );
+    if (existing) return { id: existing.id, created: false };
+
+    const [created] = await this.dataSource.query(
+      `INSERT INTO freight.warehouses (code, name, type, facility_id, status, is_active,
+                                       current_weight, current_containers, current_volume)
+       VALUES ($1, $2, $3, $4, 'ACTIVE', true, 0, 0, 0)
+       RETURNING id`,
+      [code, name, type, facilityId],
+    );
+    return { id: created.id, created: true };
+  }
+
+  private async upsertYard(
+    warehouseId: string,
+    code: string,
+    name: string,
+    cfg: { type: string; capacityContainers: number | null },
+  ): Promise<{ id: string; created: boolean }> {
+    const [existing] = await this.dataSource.query(
+      `SELECT id FROM freight.warehouse_yards
+        WHERE warehouse_id = $1 AND code = $2 AND deleted_at IS NULL`,
+      [warehouseId, code],
+    );
+    if (existing) return { id: existing.id, created: false };
+
+    const [created] = await this.dataSource.query(
+      `INSERT INTO freight.warehouse_yards (warehouse_id, code, name, type, capacity_containers,
+                                            status, is_active, current_weight, current_containers, current_volume)
+       VALUES ($1, $2, $3, $4, $5, 'ACTIVE', true, 0, 0, 0)
+       RETURNING id`,
+      [warehouseId, code, name, cfg.type, cfg.capacityContainers],
+    );
+    return { id: created.id, created: true };
+  }
+
+  private async upsertZone(
+    yardId: string,
+    code: string,
+    name: string,
+    capacityContainers: number,
+  ): Promise<{ id: string; created: boolean }> {
+    const [existing] = await this.dataSource.query(
+      `SELECT id FROM freight.warehouse_zones WHERE yard_id = $1 AND code = $2 AND deleted_at IS NULL`,
+      [yardId, code],
+    );
+    if (existing) return { id: existing.id, created: false };
+
+    const [created] = await this.dataSource.query(
+      `INSERT INTO freight.warehouse_zones (yard_id, code, name, type, capacity_containers,
+                                            status, is_active, current_weight, current_containers, current_volume)
+       VALUES ($1, $2, $3, 'CONTAINER_ZONE', $4, 'ACTIVE', true, 0, 0, 0)
+       RETURNING id`,
+      [yardId, code, name, capacityContainers],
+    );
+    return { id: created.id, created: true };
+  }
+
+  private async upsertStack(
+    zoneId: string,
+    code: string,
+    maxStackHeight: number,
+  ): Promise<{ id: string; created: boolean }> {
+    const [existing] = await this.dataSource.query(
+      `SELECT id FROM freight.warehouse_zone_stacks WHERE zone_id = $1 AND code = $2 AND deleted_at IS NULL`,
+      [zoneId, code],
+    );
+    if (existing) return { id: existing.id, created: false };
+
+    const [created] = await this.dataSource.query(
+      `INSERT INTO freight.warehouse_zone_stacks (zone_id, code, max_stack_height, status, is_active)
+       VALUES ($1, $2, $3, 'ACTIVE', true)
+       RETURNING id`,
+      [zoneId, code, maxStackHeight],
+    );
+    return { id: created.id, created: true };
+  }
+
+  private async upsertSlots(stackId: string, height: number): Promise<number> {
+    const result = await this.dataSource.query(
+      `INSERT INTO freight.warehouse_zone_slots (stack_id, level, status, is_active)
+       SELECT $1, lvl, 'AVAILABLE', true
+         FROM generate_series(1, $2) AS lvl
+        WHERE NOT EXISTS (
+          SELECT 1 FROM freight.warehouse_zone_slots s
+           WHERE s.stack_id = $1 AND s.level = lvl AND s.deleted_at IS NULL
+        )
+       RETURNING id`,
+      [stackId, height],
+    );
+    return Array.isArray(result) ? result.length : 0;
+  }
+}
diff --git a/apps/edr-freight-web/backoffice/src/App.tsx b/apps/edr-freight-web/backoffice/src/App.tsx
index a2af15786..539f2ee98 100644
--- a/apps/edr-freight-web/backoffice/src/App.tsx
+++ b/apps/edr-freight-web/backoffice/src/App.tsx
@@ -96,6 +96,7 @@ import TrainBuilderDetailPage from "./pages/trainBuilder/TrainBuilderDetailPage"
 import TrainBuilderListPage from "./pages/trainBuilder/TrainBuilderListPage";
 import ArrivalQueuePage from "./pages/warehouses/ArrivalQueuePage";
 import ContainerReturnsPage from "./pages/warehouses/ContainerReturnsPage";
+import RegisterFullContainersPage from "./pages/warehouses/RegisterFullContainersPage";
 import DispatchQueuePage from "./pages/warehouses/DispatchQueuePage";
 import ExportDjiboutiUnloadingQueuePage from "./pages/warehouses/ExportDjiboutiUnloadingQueuePage";
 import ExportWarehouseFlowPage from "./pages/warehouses/ExportWarehouseFlowPage";
@@ -708,6 +709,16 @@ const App = () => {
             </RequirePermission>
           }
         />
+        <Route
+          path="register-full-containers"
+          element={
+            <RequirePermission
+              permission={FREIGHT_PERMS.warehouseInventory.receive}
+            >
+              <RegisterFullContainersPage />
+            </RequirePermission>
+          }
+        />
         <Route
           path="loaded-inventory"
           element={
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/BookingPricingSummary.tsx b/apps/edr-freight-web/backoffice/src/components/bookings/BookingPricingSummary.tsx
index 814fb9a95..0cf206350 100644
--- a/apps/edr-freight-web/backoffice/src/components/bookings/BookingPricingSummary.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/BookingPricingSummary.tsx
@@ -1,12 +1,32 @@
 import { Banknote, Receipt } from "lucide-react";
 import { Divider, Group, Paper, Stack, Text } from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
 
+import { api } from "@/services/api";
 import type { BookingDetail } from "@/types/booking";
 
 import { SectionCard } from "./detail/SectionCard";
 import { detailStyles } from "./detail/booking-detail.styles";
 
 export function BookingPricingSummary({ booking }: { booking: BookingDetail }) {
+  // The booking's own freight invoice: source `booking`, sourceId = booking id
+  // (which `search` matches). Newest first — a re-issue supersedes the old one.
+  const invoiceQuery = useQuery(
+    api.invoices.list.queryOptions({
+      input: {
+        filter: {
+          page: 1,
+          pageSize: 1,
+          sources: "booking",
+          search: booking.id,
+          sortBy: "createdAt",
+          sortOrder: "DESC",
+        },
+      },
+    }),
+  );
+  const invoiceNumber = invoiceQuery.data?.items[0]?.invoiceNumber ?? null;
+
   const computed = Number(booking.totalAmount);
   // The booking price is computed from the contract and is NOT staff-editable.
   // A historical `adjustedTotalAmount` (from before adjustments were removed)
@@ -49,6 +69,7 @@ export function BookingPricingSummary({ booking }: { booking: BookingDetail }) {
         </Paper>
 
         <Row label="Payment status" value={booking.paymentStatus} />
+        {invoiceNumber && <Row label="Invoice number" value={invoiceNumber} mono />}
         {booking.pnrCode && <Row label="PNR code" value={booking.pnrCode} mono />}
 
         {lineItems.length > 0 && (
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
index eaa399f03..86641c7be 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/GlCreateBookingForm.tsx
@@ -118,6 +118,7 @@ const blockNegative = (event: KeyboardEvent<HTMLInputElement>) => {
 
 interface UnitErrors {
   containerNumber?: string;
+  sealNumber?: string;
   vgmTons?: string;
 }
 
@@ -886,6 +887,9 @@ export default function GlCreateBookingForm() {
         } else if ((numberCounts.get(key) ?? 0) > 1) {
           errs.containerNumber = "Duplicate container number in this shipment.";
         }
+        if (u.sealNumber.trim() === "") {
+          errs.sealNumber = "Seal number is required.";
+        }
         const vgm = Number(u.vgmTons);
         if (u.vgmTons.trim() === "" || Number.isNaN(vgm) || vgm <= 0) {
           errs.vgmTons = "Enter a valid VGM.";
@@ -1185,7 +1189,7 @@ export default function GlCreateBookingForm() {
             : {}),
           units: l.units.map((u) => ({
             containerNumber: u.containerNumber.trim().toUpperCase(),
-            ...(u.sealNumber ? { sealNumber: u.sealNumber } : {}),
+            sealNumber: u.sealNumber.trim(),
             vgmTons: Number(u.vgmTons) || 0,
             // Per-container handling — the server rolls these into the line
             // counts and bills each surcharge on the ticked containers only.
@@ -1247,7 +1251,7 @@ export default function GlCreateBookingForm() {
           reeferQuantity: Number(l.reeferQuantity || 0) || undefined,
           units: l.units.map((u) => ({
             containerNumber: u.containerNumber.trim().toUpperCase(),
-            ...(u.sealNumber ? { sealNumber: u.sealNumber } : {}),
+            sealNumber: u.sealNumber.trim(),
             vgmTons: Number(u.vgmTons) || 0,
             isHazardous: Boolean(u.isHazardous),
             isReefer: Boolean(u.isReefer),
@@ -1857,7 +1861,7 @@ export default function GlCreateBookingForm() {
                             Container number *
                           </Text>
                           <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
-                            Seal number
+                            Seal number *
                           </Text>
                           <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
                             VGM (tons) *
@@ -1901,8 +1905,13 @@ export default function GlCreateBookingForm() {
                             style={{ flex: 1 }}
                           />
                           <TextInput
-                            placeholder="Optional"
+                            placeholder="e.g. SL-0099231"
                             value={unit.sealNumber}
+                            error={
+                              showErrors
+                                ? unitErrors[lineIdx]?.[unitIdx]?.sealNumber
+                                : undefined
+                            }
                             onChange={(e) =>
                               patchUnit(lineIdx, unitIdx, {
                                 sealNumber: e.currentTarget.value,
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/gl-booking-form/container-excel.ts b/apps/edr-freight-web/backoffice/src/components/contracts/gl-booking-form/container-excel.ts
index c00091bfc..fd34bd967 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/gl-booking-form/container-excel.ts
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/gl-booking-form/container-excel.ts
@@ -151,6 +151,11 @@ export async function parseContainerExcel(
       numberCounts.set(containerNumber, (numberCounts.get(containerNumber) ?? 0) + 1);
     }
 
+    const sealNumber = cell("sealNumber");
+    if (!sealNumber) {
+      errors.push(`Row ${rowNo}: seal number is required.`);
+    }
+
     const vgmRaw = cell("vgmTons");
     const vgm = Number(vgmRaw);
     if (!vgmRaw || Number.isNaN(vgm) || vgm <= 0) {
@@ -160,7 +165,7 @@ export async function parseContainerExcel(
     rows.push({
       containerSize: size ?? "",
       containerNumber,
-      sealNumber: cell("sealNumber"),
+      sealNumber,
       vgmTons: vgmRaw,
       hazardous: opts.includeHazardous && parseFlag(cell("hazardous")),
       reefer: opts.includeReefer && parseFlag(cell("reefer")),
diff --git a/apps/edr-freight-web/backoffice/src/components/layout/sidebar-sections.tsx b/apps/edr-freight-web/backoffice/src/components/layout/sidebar-sections.tsx
index 233d67d2f..8ae6b6c47 100644
--- a/apps/edr-freight-web/backoffice/src/components/layout/sidebar-sections.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/layout/sidebar-sections.tsx
@@ -18,6 +18,7 @@ import {
   Package,
   PackageCheck,
   PackageOpen,
+  PackagePlus,
   Paperclip,
   Receipt,
   Stamp,
@@ -366,6 +367,12 @@ export const buildSidebarSections = (
               icon: <Container />,
               permission: FREIGHT_PERMS.warehouseInventory.view,
             },
+            {
+              label: "Register Full Containers",
+              href: "/dashboard/register-full-containers",
+              icon: <PackagePlus />,
+              permission: FREIGHT_PERMS.warehouseInventory.receive,
+            },
             {
               label: "Terminal Inventory",
               href: "/dashboard/warehouse-inventory?direction=IMPORT",
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/BulkContainerReturnModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/BulkContainerReturnModal.tsx
new file mode 100644
index 000000000..e2cfadb89
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/BulkContainerReturnModal.tsx
@@ -0,0 +1,347 @@
+import { useEffect, useMemo, useState } from "react";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import {
+  Alert,
+  Autocomplete,
+  Badge,
+  Button,
+  FileInput,
+  Group,
+  List,
+  Modal,
+  ScrollArea,
+  Select,
+  Stack,
+  Table,
+  Text,
+} from "@mantine/core";
+import { Upload } from "lucide-react";
+
+import { localNowForInput } from "@/lib/format";
+import { useToast } from "@/hooks/use-toast";
+import { useWarehouseYards, useWarehouseZones } from "@/hooks/useWarehouses";
+import { importOperationsService } from "@/services/importOperations.service";
+import { warehouseService } from "@/services/warehouse.service";
+import type { CreateEmptyContainerReturnPayload } from "@/types/importOperations";
+
+import { parseContainerReturnExcel, type ParsedReturnRow } from "./container-return-excel";
+import { useCompanyOptions } from "./useCompanyOptions";
+
+interface BulkContainerReturnModalProps {
+  opened: boolean;
+  onClose: () => void;
+  onUploaded: () => void;
+}
+
+/**
+ * Backfill of empties physically in a yard but never entered in the system.
+ * The sheet carries per-container detail; the fields above the file are the
+ * defaults for every row whose cell is blank, so the common case is a sheet of
+ * container numbers plus one warehouse picked here.
+ */
+export default function BulkContainerReturnModal({
+  opened,
+  onClose,
+  onUploaded,
+}: BulkContainerReturnModalProps) {
+  const { toast } = useToast();
+  const companies = useCompanyOptions();
+
+  const [file, setFile] = useState<File | null>(null);
+  const [rows, setRows] = useState<ParsedReturnRow[]>([]);
+  const [parseErrors, setParseErrors] = useState<string[]>([]);
+  const [parsing, setParsing] = useState(false);
+
+  const [company, setCompany] = useState("");
+  const [returnedBy, setReturnedBy] = useState<"EDR" | "CUSTOMER" | null>(null);
+  const [warehouseId, setWarehouseId] = useState<string | null>(null);
+  const [yardId, setYardId] = useState<string | null>(null);
+  const [zoneId, setZoneId] = useState<string | null>(null);
+  const [returnDate, setReturnDate] = useState(localNowForInput());
+
+  const { data: warehousesResponse } = useQuery({
+    queryKey: ["warehouses-list"],
+    queryFn: () => warehouseService.list({}),
+  });
+  const warehouses = ((warehousesResponse as any)?.data ?? warehousesResponse ?? []) as any[];
+  const { data: yards } = useWarehouseYards(warehouseId ?? undefined);
+  const { data: zones } = useWarehouseZones(yardId ?? undefined);
+
+  useEffect(() => {
+    setYardId(null);
+    setZoneId(null);
+  }, [warehouseId]);
+  useEffect(() => setZoneId(null), [yardId]);
+
+  const warehouseOptions = Array.isArray(warehouses)
+    ? warehouses.map((wh) => ({ value: wh.id, label: wh.code ? `${wh.name} (${wh.code})` : wh.name }))
+    : [];
+  const yardOptions = (yards ?? [])
+    .filter((y) => y.status === "ACTIVE")
+    .map((y) => ({ value: y.id, label: `${y.name} (${y.code})` }));
+  const zoneOptions = (zones ?? [])
+    .filter((z) => z.status === "ACTIVE")
+    .map((z) => ({ value: z.id, label: `${z.name} (${z.code})` }));
+
+  const defaults = useMemo(
+    () => ({
+      facility: warehouses.find((wh) => wh.id === warehouseId)?.name ?? "",
+      yard: yards?.find((y) => y.id === yardId)?.name ?? "",
+      zone: zones?.find((z) => z.id === zoneId)?.name ?? "",
+    }),
+    [warehouses, warehouseId, yards, yardId, zones, zoneId],
+  );
+
+  const reset = () => {
+    setFile(null);
+    setRows([]);
+    setParseErrors([]);
+  };
+
+  const handleFile = async (next: File | null) => {
+    setFile(next);
+    setRows([]);
+    setParseErrors([]);
+    if (!next) return;
+    setParsing(true);
+    const result = await parseContainerReturnExcel(next);
+    setParsing(false);
+    setRows(result.rows);
+    setParseErrors(result.errors);
+  };
+
+  // Row cell wins; the field above the file fills the blanks.
+  const toPayload = (row: ParsedReturnRow): CreateEmptyContainerReturnPayload => {
+    const companyName = row.companyName || company;
+    return {
+      containerNumber: row.containerNumber,
+      containerSize: row.containerSize ?? undefined,
+      companyName: companyName || undefined,
+      customerId: companyName ? companies.resolveId(companyName) : undefined,
+      returnedBy: row.returnedBy ?? returnedBy ?? undefined,
+      returnDate: row.returnDate ?? new Date(returnDate).toISOString(),
+      facility: row.facility || defaults.facility || undefined,
+      yard: row.yard || defaults.yard || undefined,
+      zone: row.zone || defaults.zone || undefined,
+      condition: row.condition || undefined,
+      handoverNote: row.handoverNote || undefined,
+    };
+  };
+
+  const uploadMutation = useMutation({
+    mutationFn: () => importOperationsService.bulkCreateEmptyReturns(rows.map(toPayload)),
+    onSuccess: (created) => {
+      toast({ title: `${created.length} container return${created.length === 1 ? "" : "s"} recorded` });
+      reset();
+      onUploaded();
+      onClose();
+    },
+    onError: (error: any) => {
+      toast({
+        variant: "destructive",
+        title: "Bulk upload failed",
+        description: error?.response?.data?.message || error?.message,
+      });
+    },
+  });
+
+  // Every row needs a warehouse from somewhere — the API stores facility as
+  // free text, so a blank one would silently produce unplaceable containers.
+  const missingFacility = rows.filter((r) => !r.facility && !defaults.facility).length;
+  const missingReturnedBy = rows.filter((r) => !r.returnedBy && !returnedBy).length;
+  const blockers = [
+    missingFacility > 0 ? `${missingFacility} row(s) have no facility — pick a default warehouse.` : null,
+    missingReturnedBy > 0 ? `${missingReturnedBy} row(s) have no "Returned By" — pick a default.` : null,
+  ].filter(Boolean) as string[];
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={() => {
+        reset();
+        onClose();
+      }}
+      title="Bulk Upload Container Returns"
+      size="xl"
+    >
+      <Stack gap="md">
+        <Text size="sm" c="dimmed">
+          For empties already sitting in the yard but not yet on the system. Values below fill any
+          blank cell in the sheet.
+        </Text>
+
+        <Group grow align="flex-start">
+          <Autocomplete
+            label="Company"
+            description="Pick a registered customer, or type a company that is not on the system yet"
+            placeholder={companies.loading ? "Loading companies…" : "Search or type a company"}
+            data={companies.names}
+            value={company}
+            onChange={setCompany}
+            limit={20}
+          />
+          <Select
+            label="Returned By"
+            placeholder="Select truck type"
+            value={returnedBy}
+            onChange={(v) => setReturnedBy(v as "EDR" | "CUSTOMER" | null)}
+            data={[
+              { value: "EDR", label: "EDR Truck" },
+              { value: "CUSTOMER", label: "Customer Truck" },
+            ]}
+          />
+        </Group>
+
+        <Group grow align="flex-start">
+          <Select
+            label="Warehouse"
+            placeholder="Select warehouse"
+            value={warehouseId}
+            onChange={setWarehouseId}
+            data={warehouseOptions}
+            searchable
+          />
+          <Select
+            label="Yard"
+            placeholder={warehouseId ? "Select yard" : "Select warehouse first"}
+            value={yardId}
+            onChange={setYardId}
+            data={yardOptions}
+            disabled={!warehouseId}
+            searchable
+          />
+          <Select
+            label="Zone"
+            placeholder={yardId ? "Select zone" : "Select yard first"}
+            value={zoneId}
+            onChange={setZoneId}
+            data={zoneOptions}
+            disabled={!yardId}
+            searchable
+          />
+        </Group>
+
+        <Group grow align="flex-start">
+          <FileInput
+            label="Excel file"
+            placeholder="Select .xlsx or .xls"
+            accept=".xlsx,.xls"
+            leftSection={<Upload size={16} />}
+            value={file}
+            onChange={(next) => void handleFile(next)}
+          />
+          <div>
+            <Text size="sm" fw={500} mb={4}>
+              Returned Date &amp; Time (default)
+            </Text>
+            <input
+              type="datetime-local"
+              value={returnDate}
+              onChange={(e) => setReturnDate(e.target.value)}
+              style={{ padding: "8px", borderRadius: "4px", border: "1px solid #ced4da", width: "100%" }}
+            />
+          </div>
+        </Group>
+
+        {parsing && <Text size="sm">Reading file…</Text>}
+
+        {parseErrors.length > 0 && (
+          <Alert color="red" title={`${parseErrors.length} problem(s) — nothing was imported`}>
+            <ScrollArea.Autosize mah={200}>
+              <List size="sm">
+                {parseErrors.map((err) => (
+                  <List.Item key={err}>{err}</List.Item>
+                ))}
+              </List>
+            </ScrollArea.Autosize>
+          </Alert>
+        )}
+
+        {blockers.length > 0 && (
+          <Alert color="yellow" title="Fill these in before uploading">
+            <List size="sm">
+              {blockers.map((b) => (
+                <List.Item key={b}>{b}</List.Item>
+              ))}
+            </List>
+          </Alert>
+        )}
+
+        {rows.length > 0 && (
+          <Stack gap="xs">
+            <Group gap="xs">
+              <Text fw={600} size="sm">
+                Preview
+              </Text>
+              <Badge size="sm">{rows.length} containers</Badge>
+            </Group>
+            <ScrollArea.Autosize mah={300}>
+              <Table striped highlightOnHover withTableBorder>
+                <Table.Thead>
+                  <Table.Tr>
+                    <Table.Th>Container</Table.Th>
+                    <Table.Th>Size</Table.Th>
+                    <Table.Th>Company</Table.Th>
+                    <Table.Th>Returned By</Table.Th>
+                    <Table.Th>Date</Table.Th>
+                    <Table.Th>Facility</Table.Th>
+                    <Table.Th>Yard</Table.Th>
+                  </Table.Tr>
+                </Table.Thead>
+                <Table.Tbody>
+                  {rows.map((row) => {
+                    const payload = toPayload(row);
+                    return (
+                      <Table.Tr key={row.containerNumber}>
+                        <Table.Td>{payload.containerNumber}</Table.Td>
+                        <Table.Td>{payload.containerSize ? `${payload.containerSize} ft` : "—"}</Table.Td>
+                        <Table.Td>
+                          <Group gap={4} wrap="nowrap">
+                            <Text size="sm">{payload.companyName || "—"}</Text>
+                            {payload.companyName && !payload.customerId && (
+                              <Badge size="xs" color="orange" variant="light">
+                                New
+                              </Badge>
+                            )}
+                          </Group>
+                        </Table.Td>
+                        <Table.Td>{payload.returnedBy ?? "—"}</Table.Td>
+                        <Table.Td>
+                          {payload.returnDate
+                            ? new Date(payload.returnDate).toLocaleDateString()
+                            : "—"}
+                        </Table.Td>
+                        <Table.Td>{payload.facility ?? "—"}</Table.Td>
+                        <Table.Td>{payload.yard ?? "—"}</Table.Td>
+                      </Table.Tr>
+                    );
+                  })}
+                </Table.Tbody>
+              </Table>
+            </ScrollArea.Autosize>
+          </Stack>
+        )}
+
+        <Group justify="flex-end" gap="sm">
+          <Button
+            variant="default"
+            onClick={() => {
+              reset();
+              onClose();
+            }}
+            disabled={uploadMutation.isPending}
+          >
+            Cancel
+          </Button>
+          <Button
+            onClick={() => uploadMutation.mutate()}
+            disabled={rows.length === 0 || blockers.length > 0}
+            loading={uploadMutation.isPending}
+          >
+            Upload {rows.length > 0 ? `${rows.length} containers` : ""}
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
index 8c8560442..ca199e0cd 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/CreateWarehouseModal.tsx
@@ -13,8 +13,19 @@ import { useMutation, useQuery } from '@tanstack/react-query';
 
 import { api } from '@/services/api';
 import { useToast } from '@/hooks/use-toast';
-import type { SaveWarehousePayload, Warehouse, WarehouseType } from '@/types/warehouse';
-import { extractErrorMessage, lettersOnly, statusOptions, warehouseTypeOptions } from './options';
+import type {
+  SaveWarehousePayload,
+  Warehouse,
+  WarehouseFreightType,
+  WarehouseType,
+} from '@/types/warehouse';
+import {
+  extractErrorMessage,
+  lettersOnly,
+  statusOptions,
+  warehouseFreightTypeOptions,
+  warehouseTypeOptions,
+} from './options';
 
 interface CreateWarehouseModalProps {
   opened: boolean;
@@ -26,6 +37,7 @@ interface FormState {
   name: string;
   code: string;
   type: WarehouseType;
+  freightType: WarehouseFreightType | null;
   stationId: string | null;
   locationName: string;
   capacityWeight: number | '';
@@ -38,6 +50,7 @@ const emptyForm = (): FormState => ({
   name: '',
   code: '',
   type: 'OPEN_WAREHOUSE',
+  freightType: null,
   stationId: null,
   locationName: '',
   capacityWeight: '',
@@ -66,6 +79,7 @@ export function CreateWarehouseModal({ opened, onClose, warehouse }: CreateWareh
               name: warehouse.name,
               code: warehouse.code,
               type: warehouse.type,
+              freightType: warehouse.freightType ?? null,
               stationId: warehouse.stationId ?? null,
               locationName: warehouse.locationName ?? '',
               capacityWeight: warehouse.capacityWeight ?? '',
@@ -90,6 +104,7 @@ export function CreateWarehouseModal({ opened, onClose, warehouse }: CreateWareh
       name: form.name.trim(),
       code: form.code.trim(),
       type: form.type,
+      freightType: form.freightType,
       stationId: form.stationId ?? undefined,
       locationName: form.locationName.trim() || undefined,
       capacityWeight: form.capacityWeight === '' ? undefined : Number(form.capacityWeight),
@@ -142,6 +157,14 @@ export function CreateWarehouseModal({ opened, onClose, warehouse }: CreateWareh
         />
 
         <Group grow>
+          <Select
+            label="Freight type"
+            placeholder="Both"
+            data={warehouseFreightTypeOptions}
+            value={form.freightType}
+            onChange={(value) => setForm((f) => ({ ...f, freightType: value as WarehouseFreightType | null }))}
+            clearable
+          />
           <Select
             label="Type"
             data={warehouseTypeOptions}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/MoveInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/MoveInventoryModal.tsx
index 1ec596ffe..b7de47ef9 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/MoveInventoryModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/MoveInventoryModal.tsx
@@ -1,5 +1,6 @@
 import { useEffect, useMemo, useState } from 'react';
-import { Button, Group, Modal, Select, Stack, Textarea } from '@mantine/core';
+import { Alert, Button, Group, List, Modal, Select, Stack, Textarea, Text } from '@mantine/core';
+import { Layers } from 'lucide-react';
 
 import { useMutation, useQuery } from '@tanstack/react-query';
 
@@ -7,6 +8,7 @@ import { api } from '@/services/api';
 import { useToast } from '@/hooks/use-toast';
 import type { WarehouseInventoryItem } from '@/types/warehouse';
 import { extractErrorMessage } from './options';
+import { SlotPicker } from './SlotPicker';
 
 interface MoveInventoryModalProps {
   opened: boolean;
@@ -20,6 +22,7 @@ export function MoveInventoryModal({ opened, onClose, item }: MoveInventoryModal
   const [warehouseId, setWarehouseId] = useState('');
   const [yardId, setYardId] = useState('');
   const [zoneId, setZoneId] = useState('');
+  const [slotId, setSlotId] = useState('');
   const [remarks, setRemarks] = useState('');
 
   useEffect(() => {
@@ -27,10 +30,22 @@ export function MoveInventoryModal({ opened, onClose, item }: MoveInventoryModal
       setWarehouseId('');
       setYardId('');
       setZoneId('');
+      setSlotId('');
       setRemarks('');
     }
   }, [opened]);
 
+  // A container with boxes stacked on top of it cannot be lifted out — the API
+  // refuses the move, so the button says why instead of firing a 409.
+  const accessibilityQuery = useQuery(
+    api.warehouses.containerAccessibility.queryOptions({
+      input: { id: item?.id ?? '' },
+      enabled: opened && Boolean(item?.id),
+    }),
+  );
+  const accessibility = accessibilityQuery.data;
+  const blocked = accessibility ? !accessibility.accessible : false;
+
   const warehousesQuery = useQuery(
     api.warehouses.list.queryOptions({ input: { filter: { status: 'ACTIVE' } } }),
   );
@@ -69,7 +84,13 @@ export function MoveInventoryModal({ opened, onClose, item }: MoveInventoryModal
     try {
       await moveMutation.mutateAsync({
         id: item.id,
-        payload: { warehouseId, yardId, zoneId, remarks: remarks.trim() || undefined },
+        payload: {
+          warehouseId,
+          yardId,
+          zoneId,
+          slotId: slotId || undefined,
+          remarks: remarks.trim() || undefined,
+        },
       });
       toast({ title: 'Inventory moved' });
       onClose();
@@ -81,6 +102,22 @@ export function MoveInventoryModal({ opened, onClose, item }: MoveInventoryModal
   return (
     <Modal opened={opened} onClose={onClose} title="Move inventory" centered size="lg">
       <Stack gap="md">
+        {blocked && accessibility ? (
+          <Alert icon={<Layers size={16} />} color="orange" variant="light" title="Container is buried">
+            <Text size="sm">
+              It sits at {accessibility.stackCode} level {accessibility.level} with{' '}
+              {accessibility.blockingContainers.length} container(s) stacked on top. Move these out
+              first:
+            </Text>
+            <List size="sm" mt={4}>
+              {accessibility.blockingContainers.map((b) => (
+                <List.Item key={b.inventoryId}>
+                  {b.containerNumber ?? 'Container'} — level {b.level}
+                </List.Item>
+              ))}
+            </List>
+          </Alert>
+        ) : null}
         <Select
           label="Destination warehouse"
           placeholder="Select warehouse"
@@ -115,8 +152,13 @@ export function MoveInventoryModal({ opened, onClose, item }: MoveInventoryModal
           disabled={!yardId}
           data={zoneOptions}
           value={zoneId || null}
-          onChange={(v) => setZoneId(v ?? '')}
+          onChange={(v) => {
+            setZoneId(v ?? '');
+            setSlotId('');
+          }}
         />
+        {/* Container yards only — the picker hides itself where no stacks exist. */}
+        <SlotPicker zoneId={zoneId} value={slotId} onChange={setSlotId} label="Destination stack position" />
         <Textarea
           label="Remarks"
           placeholder="Reason for the move"
@@ -129,7 +171,12 @@ export function MoveInventoryModal({ opened, onClose, item }: MoveInventoryModal
           <Button variant="default" onClick={onClose} disabled={moveMutation.isPending}>
             Cancel
           </Button>
-          <Button onClick={handleSubmit} loading={moveMutation.isPending}>
+          <Button
+            onClick={handleSubmit}
+            loading={moveMutation.isPending}
+            disabled={blocked}
+            title={blocked ? 'Containers stacked above this one must be moved first' : undefined}
+          >
             Move inventory
           </Button>
         </Group>
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/SlotPicker.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/SlotPicker.tsx
new file mode 100644
index 000000000..e30444277
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/SlotPicker.tsx
@@ -0,0 +1,87 @@
+import { useMemo } from 'react';
+import { Select, Text } from '@mantine/core';
+import { useQuery } from '@tanstack/react-query';
+
+import { api } from '@/services/api';
+import type { ZoneLayout } from '@/types/warehouse';
+
+interface SlotPickerProps {
+  zoneId: string;
+  value: string;
+  onChange: (slotId: string) => void;
+  label?: string;
+  disabled?: boolean;
+}
+
+/**
+ * The stack levels a container may actually be put on right now.
+ *
+ * Only the next fillable level of each stack is offered: a box cannot stand on
+ * level 2 while level 1 is empty, so listing level 3 of an empty stack would
+ * only produce a rejected request. The server enforces the same rule — this
+ * mirrors it so the operator never sees a 400 for a position the form offered.
+ */
+export function fillableLevels(layout: ZoneLayout | undefined) {
+  if (!layout) return [];
+
+  return layout.stacks
+    .filter((stack) => stack.isActive && stack.status === 'ACTIVE')
+    .flatMap((stack) => {
+      const occupied = stack.slots
+        .filter((slot) => slot.effectiveStatus === 'OCCUPIED')
+        .map((slot) => slot.level);
+      const top = occupied.length > 0 ? Math.max(...occupied) : 0;
+      if (top >= stack.maxStackHeight) return [];
+
+      const next = stack.slots.find(
+        (slot) => slot.level === top + 1 && slot.effectiveStatus === 'AVAILABLE',
+      );
+      if (!next) return [];
+
+      return [
+        {
+          value: next.slotId,
+          label: `${stack.code} — level ${next.level}${top > 0 ? ` (on ${top} container${top > 1 ? 's' : ''})` : ' (ground)'}`,
+        },
+      ];
+    });
+}
+
+export function SlotPicker({ zoneId, value, onChange, label = 'Stack position', disabled }: SlotPickerProps) {
+  const { data, isLoading } = useQuery(
+    api.warehouses.zoneLayout.queryOptions({
+      input: { zoneId },
+      enabled: Boolean(zoneId),
+    }),
+  );
+
+  const options = useMemo(() => fillableLevels(data), [data]);
+
+  // A zone with no stacks configured keeps plain zone-level placement — showing
+  // an empty picker there would imply a choice that does not exist.
+  if (!zoneId || (!isLoading && (data?.stacks.length ?? 0) === 0)) return null;
+
+  return (
+    <Select
+      label={label}
+      description={
+        options.length === 0 && !isLoading ? (
+          <Text size="xs" c="orange">
+            Every stack in this zone is full or blocked — the item will be stored at zone level.
+          </Text>
+        ) : (
+          'Leave blank to take the lowest free level automatically.'
+        )
+      }
+      placeholder={isLoading ? 'Loading positions…' : 'Automatic (lowest free level)'}
+      searchable
+      clearable
+      disabled={disabled || isLoading || options.length === 0}
+      data={options}
+      value={value || null}
+      onChange={(v) => onChange(v ?? '')}
+    />
+  );
+}
+
+export default SlotPicker;
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/StoreInventoryModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/StoreInventoryModal.tsx
index f1a5aa4ad..c9051dba6 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/StoreInventoryModal.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/StoreInventoryModal.tsx
@@ -8,6 +8,7 @@ import { api } from '@/services/api';
 import { useToast } from '@/hooks/use-toast';
 import type { WarehouseInventoryItem } from '@/types/warehouse';
 import { extractErrorMessage } from './options';
+import { SlotPicker } from './SlotPicker';
 
 interface StoreInventoryModalProps {
   opened: boolean;
@@ -25,12 +26,14 @@ export function StoreInventoryModal({ opened, onClose, item }: StoreInventoryMod
   const [warehouseId, setWarehouseId] = useState('');
   const [yardId, setYardId] = useState('');
   const [zoneId, setZoneId] = useState('');
+  const [slotId, setSlotId] = useState('');
 
   useEffect(() => {
     if (opened) {
       setWarehouseId('');
       setYardId('');
       setZoneId('');
+      setSlotId('');
     }
   }, [opened]);
 
@@ -75,7 +78,7 @@ export function StoreInventoryModal({ opened, onClose, item }: StoreInventoryMod
     try {
       await storeMutation.mutateAsync({
         id: item.id,
-        payload: manualComplete ? { warehouseId, yardId, zoneId } : undefined,
+        payload: manualComplete ? { warehouseId, yardId, zoneId, slotId: slotId || undefined } : undefined,
       });
       toast({ title: manualComplete ? 'Inventory stored at selected location' : 'Inventory stored (auto-allocated)' });
       onClose();
@@ -127,8 +130,13 @@ export function StoreInventoryModal({ opened, onClose, item }: StoreInventoryMod
           disabled={!yardId}
           data={zoneOptions}
           value={zoneId || null}
-          onChange={(v) => setZoneId(v ?? '')}
+          onChange={(v) => {
+            setZoneId(v ?? '');
+            setSlotId('');
+          }}
         />
+        {/* Container yards only — the picker hides itself where no stacks exist. */}
+        <SlotPicker zoneId={zoneId} value={slotId} onChange={setSlotId} />
         <Group justify="flex-end" mt="sm">
           <Button variant="default" onClick={onClose} disabled={storeMutation.isPending}>
             Cancel
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseCardView.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseCardView.tsx
index c6baed7ca..ceb616e45 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseCardView.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseCardView.tsx
@@ -1,6 +1,6 @@
 import { useMemo } from 'react';
 import { ActionIcon, Box, Card, Divider, Group, Progress, SimpleGrid, Stack, Text, Tooltip } from '@mantine/core';
-import { Building2, Eye, MapPin, Package, Pencil, Weight } from 'lucide-react';
+import { Building2, Eye, MapPin, Package, Pencil, Trash2, Weight } from 'lucide-react';
 
 import { useQuery } from '@tanstack/react-query';
 
@@ -13,9 +13,11 @@ interface WarehouseCardViewProps {
   warehouses: Warehouse[];
   onView: (warehouse: Warehouse) => void;
   onEdit: (warehouse: Warehouse) => void;
+  /** Omitted when the user lacks the delete permission. */
+  onDelete?: (warehouse: Warehouse) => void;
 }
 
-export function WarehouseCardView({ warehouses, onView, onEdit }: WarehouseCardViewProps) {
+export function WarehouseCardView({ warehouses, onView, onEdit, onDelete }: WarehouseCardViewProps) {
   const { data: stations } = useQuery(
     api.stations.list.queryOptions({ staleTime: 5 * 60 * 1000 }),
   );
@@ -130,6 +132,18 @@ export function WarehouseCardView({ warehouses, onView, onEdit }: WarehouseCardV
                   <Pencil size={16} />
                 </ActionIcon>
               </Tooltip>
+              {onDelete ? (
+                <Tooltip label="Delete warehouse" withArrow>
+                  <ActionIcon
+                    variant="light"
+                    color="red"
+                    onClick={() => onDelete(warehouse)}
+                    aria-label="Delete warehouse"
+                  >
+                    <Trash2 size={16} />
+                  </ActionIcon>
+                </Tooltip>
+              ) : null}
             </Group>
           </Stack>
         </Card>
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseTable.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseTable.tsx
index 82a44f557..7dac2d8a1 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseTable.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/WarehouseTable.tsx
@@ -8,6 +8,7 @@ import {
   Package,
   Pencil,
   Scale,
+  Trash2,
   Warehouse as WarehouseIcon,
 } from 'lucide-react';
 import { DataTable, type ColumnDef } from '@edr/ui-common';
@@ -24,6 +25,8 @@ interface WarehouseTableProps {
   warehouses: Warehouse[];
   onView: (warehouse: Warehouse) => void;
   onEdit: (warehouse: Warehouse) => void;
+  /** Omitted when the user lacks the delete permission. */
+  onDelete?: (warehouse: Warehouse) => void;
 }
 
 const HEADER = bookingTable.headerCell;
@@ -63,7 +66,7 @@ function CapacityCell({
   );
 }
 
-export function WarehouseTable({ warehouses, onView, onEdit }: WarehouseTableProps) {
+export function WarehouseTable({ warehouses, onView, onEdit, onDelete }: WarehouseTableProps) {
   const { data: stations } = useQuery(
     api.stations.list.queryOptions({ staleTime: 5 * 60 * 1000 }),
   );
@@ -179,6 +182,11 @@ export function WarehouseTable({ warehouses, onView, onEdit }: WarehouseTablePro
           <ActionIcon variant="subtle" color="gray" onClick={() => onEdit(row.original)} title="Edit">
             <Pencil size={16} />
           </ActionIcon>
+          {onDelete ? (
+            <ActionIcon variant="subtle" color="red" onClick={() => onDelete(row.original)} title="Delete">
+              <Trash2 size={16} />
+            </ActionIcon>
+          ) : null}
         </Group>
       ),
       },
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneContentsModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneContentsModal.tsx
new file mode 100644
index 000000000..2c0672078
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneContentsModal.tsx
@@ -0,0 +1,119 @@
+import { Badge, Group, Loader, Modal, Text } from '@mantine/core';
+import { useQuery } from '@tanstack/react-query';
+import { DataTable, type ColumnDef } from '@edr/ui-common';
+
+import { formatDateTime, humanize } from '@/lib/format';
+import { api } from '@/services/api';
+import type { ZoneContentItem } from '@/types/warehouse';
+
+/** Enough to name the zone and fetch it — satisfied by WarehouseZone and ZoneOccupancy alike. */
+export interface ZoneRef {
+  id: string;
+  name: string;
+  code: string;
+}
+
+interface ZoneContentsModalProps {
+  opened: boolean;
+  onClose: () => void;
+  zone: ZoneRef | null;
+}
+
+const columns: ColumnDef<ZoneContentItem>[] = [
+  {
+    id: 'containerNumber',
+    header: 'Container No.',
+    // Bulk cargo has no container of its own — it still occupies the zone.
+    cell: ({ row }) => row.original.containerNumber ?? 'Bulk cargo',
+  },
+  {
+    id: 'unloadedAt',
+    header: 'Unloaded',
+    cell: ({ row }) => formatDateTime(row.original.unloadedAt),
+  },
+  {
+    id: 'containerType',
+    header: 'Type',
+    cell: ({ row }) => row.original.containerType ?? '—',
+  },
+  {
+    id: 'direction',
+    header: 'Import / Export',
+    cell: ({ row }) =>
+      row.original.direction ? (
+        <Badge color={row.original.direction === 'IMPORT' ? 'blue' : 'teal'} variant="light">
+          {humanize(row.original.direction)}
+        </Badge>
+      ) : (
+        '—'
+      ),
+  },
+  {
+    id: 'loadState',
+    header: 'Full / Empty',
+    cell: ({ row }) =>
+      row.original.loadState ? (
+        <Badge color={row.original.loadState === 'EMPTY' ? 'gray' : 'green'} variant="light">
+          {humanize(row.original.loadState)}
+        </Badge>
+      ) : (
+        '—'
+      ),
+  },
+  {
+    id: 'bookingReference',
+    header: 'Booking',
+    cell: ({ row }) => row.original.bookingReference ?? '—',
+  },
+  {
+    id: 'status',
+    header: 'Status',
+    cell: ({ row }) => humanize(row.original.status),
+  },
+];
+
+export function ZoneContentsModal({ opened, onClose, zone }: ZoneContentsModalProps) {
+  const { data, isLoading, isError } = useQuery(
+    api.warehouses.zoneContents.queryOptions({
+      input: { zoneId: zone?.id ?? '' },
+      enabled: opened && Boolean(zone?.id),
+    }),
+  );
+
+  const items = data ?? [];
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      size="xl"
+      title={
+        <Group gap="xs">
+          <Text fw={700}>{zone ? `${zone.name} (${zone.code})` : 'Zone'}</Text>
+          <Text size="sm" c="dimmed">
+            {items.length} item(s) in this zone
+          </Text>
+        </Group>
+      }
+    >
+      {isLoading ? (
+        <Group justify="center" py="xl">
+          <Loader />
+        </Group>
+      ) : isError ? (
+        <Text c="red" ta="center" py="xl">
+          Failed to load zone contents.
+        </Text>
+      ) : (
+        <DataTable
+          columns={columns}
+          data={items}
+          status="success"
+          emptyMessage="This zone is empty."
+        />
+      )}
+    </Modal>
+  );
+}
+
+export default ZoneContentsModal;
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneLayoutModal.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneLayoutModal.tsx
new file mode 100644
index 000000000..7821ee1b3
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneLayoutModal.tsx
@@ -0,0 +1,407 @@
+import { useMemo, useState } from 'react';
+import {
+  ActionIcon,
+  Badge,
+  Button,
+  Card,
+  Group,
+  Loader,
+  Menu,
+  Modal,
+  NumberInput,
+  Paper,
+  SimpleGrid,
+  Stack,
+  Text,
+  TextInput,
+  Tooltip,
+} from '@mantine/core';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { Ban, CircleSlash, Layers, MoreVertical, Plus, Trash2, Unlock } from 'lucide-react';
+
+import { useAuth } from '@/auth/useAuth';
+import { useToast } from '@/hooks/use-toast';
+import { FREIGHT_PERMS, hasPermission } from '@/lib/permissions';
+import { api } from '@/services/api';
+import type { SlotEffectiveStatus, ZoneLayoutSlot, ZoneLayoutStack } from '@/types/warehouse';
+import { extractErrorMessage } from './options';
+import type { ZoneRef } from './ZoneContentsModal';
+
+interface ZoneLayoutModalProps {
+  opened: boolean;
+  onClose: () => void;
+  zone: ZoneRef | null;
+}
+
+/** One colour per slot state, used by both the cell and the legend. */
+const SLOT_TONE: Record<SlotEffectiveStatus, { color: string; label: string }> = {
+  OCCUPIED: { color: 'blue', label: 'Occupied' },
+  AVAILABLE: { color: 'teal', label: 'Free' },
+  RESERVED: { color: 'orange', label: 'Reserved' },
+  BLOCKED: { color: 'red', label: 'Blocked' },
+  INACTIVE: { color: 'gray', label: 'Inactive' },
+};
+
+/**
+ * A container stack seen from the side: level 3 on top, level 1 on the ground —
+ * the order the API already returns and the order the yard actually looks.
+ */
+function SlotCell({
+  slot,
+  onSetStatus,
+  canEdit,
+}: {
+  slot: ZoneLayoutSlot;
+  canEdit: boolean;
+  onSetStatus: (slot: ZoneLayoutSlot, status: 'AVAILABLE' | 'BLOCKED' | 'RESERVED') => void;
+}) {
+  const tone = SLOT_TONE[slot.effectiveStatus];
+  const occupied = slot.effectiveStatus === 'OCCUPIED';
+
+  return (
+    <Paper
+      withBorder
+      radius="sm"
+      px="xs"
+      py={6}
+      style={{ borderLeft: `4px solid var(--mantine-color-${tone.color}-6)` }}
+    >
+      <Group justify="space-between" wrap="nowrap" gap="xs">
+        <Group gap={6} wrap="nowrap" style={{ minWidth: 0 }}>
+          <Text size="xs" c="dimmed" fw={600} w={20}>
+            L{slot.level}
+          </Text>
+          <Text size="sm" truncate title={slot.containerNumber ?? tone.label}>
+            {occupied ? (slot.containerNumber ?? 'Container') : tone.label}
+          </Text>
+        </Group>
+
+        {/* An occupied level has no status to set — empty it by moving the box. */}
+        {canEdit && !occupied ? (
+          <Menu position="bottom-end" withinPortal>
+            <Menu.Target>
+              <ActionIcon variant="subtle" size="sm" aria-label={`Level ${slot.level} actions`}>
+                <MoreVertical size={14} />
+              </ActionIcon>
+            </Menu.Target>
+            <Menu.Dropdown>
+              <Menu.Item
+                leftSection={<Unlock size={14} />}
+                disabled={slot.effectiveStatus === 'AVAILABLE'}
+                onClick={() => onSetStatus(slot, 'AVAILABLE')}
+              >
+                Mark free
+              </Menu.Item>
+              <Menu.Item
+                leftSection={<CircleSlash size={14} />}
+                disabled={slot.effectiveStatus === 'RESERVED'}
+                onClick={() => onSetStatus(slot, 'RESERVED')}
+              >
+                Reserve
+              </Menu.Item>
+              <Menu.Item
+                leftSection={<Ban size={14} />}
+                color="red"
+                disabled={slot.effectiveStatus === 'BLOCKED'}
+                onClick={() => onSetStatus(slot, 'BLOCKED')}
+              >
+                Block
+              </Menu.Item>
+            </Menu.Dropdown>
+          </Menu>
+        ) : null}
+      </Group>
+    </Paper>
+  );
+}
+
+function StackCard({
+  stack,
+  canEdit,
+  canDelete,
+  onSetSlotStatus,
+  onDelete,
+}: {
+  stack: ZoneLayoutStack;
+  canEdit: boolean;
+  canDelete: boolean;
+  onSetSlotStatus: (slot: ZoneLayoutSlot, status: 'AVAILABLE' | 'BLOCKED' | 'RESERVED') => void;
+  onDelete: (stack: ZoneLayoutStack) => void;
+}) {
+  const filled = stack.slots.filter((s) => s.effectiveStatus === 'OCCUPIED').length;
+
+  return (
+    <Card withBorder radius="md" padding="sm">
+      <Stack gap={8}>
+        <Group justify="space-between" wrap="nowrap" gap="xs">
+          <Group gap={6} wrap="nowrap" style={{ minWidth: 0 }}>
+            <Text fw={600} size="sm" truncate title={stack.name ?? stack.code}>
+              {stack.code}
+            </Text>
+            {stack.status !== 'ACTIVE' || !stack.isActive ? (
+              <Badge size="xs" color="gray" variant="light">
+                Inactive
+              </Badge>
+            ) : null}
+          </Group>
+          <Group gap={4} wrap="nowrap">
+            <Badge size="sm" variant="light" color={filled === stack.maxStackHeight ? 'blue' : 'gray'}>
+              {filled}/{stack.maxStackHeight}
+            </Badge>
+            {canDelete ? (
+              <Tooltip label="Delete stack">
+                <ActionIcon
+                  variant="subtle"
+                  color="red"
+                  size="sm"
+                  onClick={() => onDelete(stack)}
+                  aria-label={`Delete stack ${stack.code}`}
+                >
+                  <Trash2 size={14} />
+                </ActionIcon>
+              </Tooltip>
+            ) : null}
+          </Group>
+        </Group>
+
+        <Stack gap={4}>
+          {stack.slots.map((slot) => (
+            <SlotCell key={slot.slotId} slot={slot} canEdit={canEdit} onSetStatus={onSetSlotStatus} />
+          ))}
+        </Stack>
+      </Stack>
+    </Card>
+  );
+}
+
+/**
+ * Physical layout of one zone — every ground stack with its levels, what stands
+ * on each, and the capacity numbers that are routinely confused (configured vs
+ * built vs full). Stacks are created and retired from here, since there is
+ * nowhere else the yard layout is visible.
+ */
+export function ZoneLayoutModal({ opened, onClose, zone }: ZoneLayoutModalProps) {
+  const { toast } = useToast();
+  const { user } = useAuth();
+  const canCreate = hasPermission(user, FREIGHT_PERMS.warehouseZones.create);
+  const canEdit = hasPermission(user, FREIGHT_PERMS.warehouseZones.update);
+  const canDelete = hasPermission(user, FREIGHT_PERMS.warehouseZones.delete);
+
+  const zoneId = zone?.id ?? '';
+  const { data, isLoading, isError, refetch } = useQuery(
+    api.warehouses.zoneLayout.queryOptions({
+      input: { zoneId },
+      enabled: opened && Boolean(zoneId),
+    }),
+  );
+
+  const [creating, setCreating] = useState(false);
+  const [code, setCode] = useState('');
+  const [height, setHeight] = useState<number>(3);
+
+  const createStack = useMutation(api.warehouses.createStack.mutationOptions());
+  const deleteStack = useMutation(api.warehouses.deleteStack.mutationOptions());
+  const updateSlot = useMutation(api.warehouses.updateSlot.mutationOptions());
+
+  const stacks = data?.stacks ?? [];
+  const summary = data?.summary;
+
+  const nextCode = useMemo(() => {
+    // Suggest the next number in the zone's own series (ZA-001 → ZA-002) so
+    // codes stay sortable, which is the order the placement engine walks.
+    const numbered = stacks
+      .map((s) => /^(.*?)(\d+)$/.exec(s.code))
+      .filter((m): m is RegExpExecArray => Boolean(m));
+    if (numbered.length === 0) return '';
+    const last = numbered[numbered.length - 1];
+    const width = last[2].length;
+    const next = Math.max(...numbered.map((m) => Number(m[2]))) + 1;
+    return `${last[1]}${String(next).padStart(width, '0')}`;
+  }, [stacks]);
+
+  const submitStack = () => {
+    const trimmed = code.trim();
+    if (!trimmed) {
+      toast({ variant: 'destructive', title: 'Stack code is required' });
+      return;
+    }
+    createStack.mutate(
+      { zoneId, payload: { code: trimmed, maxStackHeight: height } },
+      {
+        onSuccess: () => {
+          toast({ title: `Stack ${trimmed} created with ${height} level(s)` });
+          setCode('');
+          setCreating(false);
+        },
+        onError: (error) =>
+          toast({
+            variant: 'destructive',
+            title: 'Could not create the stack',
+            description: extractErrorMessage(error),
+          }),
+      },
+    );
+  };
+
+  const removeStack = (stack: ZoneLayoutStack) => {
+    if (!window.confirm(`Delete stack ${stack.code}? It must be empty first.`)) return;
+    deleteStack.mutate(
+      { id: stack.stackId, zoneId },
+      {
+        onSuccess: () => toast({ title: `Stack ${stack.code} deleted` }),
+        onError: (error) =>
+          toast({
+            variant: 'destructive',
+            title: 'Could not delete the stack',
+            description: extractErrorMessage(error),
+          }),
+      },
+    );
+  };
+
+  const setSlotStatus = (slot: ZoneLayoutSlot, status: 'AVAILABLE' | 'BLOCKED' | 'RESERVED') => {
+    updateSlot.mutate(
+      { slotId: slot.slotId, zoneId, payload: { status, isActive: true } },
+      {
+        onSuccess: () => toast({ title: `Level ${slot.level} set to ${SLOT_TONE[status].label}` }),
+        onError: (error) =>
+          toast({
+            variant: 'destructive',
+            title: 'Could not update the level',
+            description: extractErrorMessage(error),
+          }),
+      },
+    );
+  };
+
+  return (
+    <Modal
+      opened={opened}
+      onClose={onClose}
+      size="xl"
+      title={
+        <Group gap="xs">
+          <Layers size={18} />
+          <Text fw={700}>{zone ? `${zone.name} (${zone.code}) layout` : 'Zone layout'}</Text>
+        </Group>
+      }
+    >
+      <Stack gap="md">
+        {summary ? (
+          <Card withBorder radius="md" padding="sm">
+            <Group gap="lg" wrap="wrap">
+              <Stat label="Configured capacity" value={summary.configuredCapacity ?? '—'} />
+              <Stat label="Slots built" value={summary.physicalSlotCount} />
+              <Stat label="Occupied" value={summary.occupiedSlotCount} color="blue" />
+              <Stat label="Free" value={summary.availableSlotCount} color="teal" />
+              <Stat label="Reserved" value={summary.reservedSlotCount} color="orange" />
+              <Stat label="Blocked" value={summary.blockedSlotCount} color="red" />
+            </Group>
+            {summary.inconsistent ? (
+              <Text size="xs" c="red" mt={6}>
+                {summary.physicalSlotCount} slots are built but the zone is configured for{' '}
+                {summary.configuredCapacity}. Raise the zone capacity or remove stacks — the
+                configured figure was left as it is.
+              </Text>
+            ) : null}
+          </Card>
+        ) : null}
+
+        <Group justify="space-between">
+          <Group gap="xs">
+            {(Object.keys(SLOT_TONE) as SlotEffectiveStatus[]).map((key) => (
+              <Badge key={key} size="xs" variant="light" color={SLOT_TONE[key].color}>
+                {SLOT_TONE[key].label}
+              </Badge>
+            ))}
+          </Group>
+          {canCreate ? (
+            <Button
+              size="xs"
+              leftSection={<Plus size={14} />}
+              variant={creating ? 'default' : 'filled'}
+              onClick={() => {
+                setCreating((open) => !open);
+                if (!creating && !code) setCode(nextCode);
+              }}
+            >
+              {creating ? 'Cancel' : 'Add stack'}
+            </Button>
+          ) : null}
+        </Group>
+
+        {creating ? (
+          <Card withBorder radius="md" padding="sm">
+            <Group align="flex-end" gap="sm">
+              <TextInput
+                label="Stack code"
+                placeholder="ZA-001"
+                value={code}
+                onChange={(e) => setCode(e.currentTarget.value)}
+                style={{ flex: 1 }}
+              />
+              <NumberInput
+                label="Levels"
+                description="One slot is created per level"
+                min={1}
+                max={10}
+                value={height}
+                onChange={(v) => setHeight(Number(v) || 1)}
+                w={140}
+              />
+              <Button onClick={submitStack} loading={createStack.isPending}>
+                Create
+              </Button>
+            </Group>
+          </Card>
+        ) : null}
+
+        {isLoading ? (
+          <Group justify="center" py="xl">
+            <Loader />
+          </Group>
+        ) : isError ? (
+          <Stack align="center" py="xl" gap="xs">
+            <Text c="red">Failed to load the zone layout.</Text>
+            <Button variant="default" size="xs" onClick={() => void refetch()}>
+              Retry
+            </Button>
+          </Stack>
+        ) : stacks.length === 0 ? (
+          <Text c="dimmed" ta="center" py="xl" size="sm">
+            No ground stacks configured in this zone yet. Containers stored here keep zone-level
+            placement until stacks exist.
+          </Text>
+        ) : (
+          <SimpleGrid cols={{ base: 1, xs: 2, sm: 3, lg: 4 }} spacing="sm">
+            {stacks.map((stack) => (
+              <StackCard
+                key={stack.stackId}
+                stack={stack}
+                canEdit={canEdit}
+                canDelete={canDelete}
+                onSetSlotStatus={setSlotStatus}
+                onDelete={removeStack}
+              />
+            ))}
+          </SimpleGrid>
+        )}
+      </Stack>
+    </Modal>
+  );
+}
+
+function Stat({ label, value, color }: { label: string; value: number | string; color?: string }) {
+  return (
+    <Stack gap={0}>
+      <Text size="xs" c="dimmed">
+        {label}
+      </Text>
+      <Text fw={700} c={color}>
+        {value}
+      </Text>
+    </Stack>
+  );
+}
+
+export default ZoneLayoutModal;
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneOccupancyHeatmap.tsx b/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneOccupancyHeatmap.tsx
index 9fcbd88ed..6ceb3e11d 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneOccupancyHeatmap.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/ZoneOccupancyHeatmap.tsx
@@ -25,13 +25,15 @@ function capacityLabel(z: ZoneOccupancy): string {
 interface ZoneOccupancyHeatmapProps {
   /** Scope to one yard; omit for all zones. */
   yardId?: string;
+  /** Pass to make each tile open that zone; omitted leaves the tiles inert. */
+  onZoneClick?: (zone: ZoneOccupancy) => void;
 }
 
 /**
  * Occupancy heatmap: one tile per zone, coloured by how full it is. Occupancy is
  * container-count based (unit-consistent); weight is shown as context only.
  */
-export function ZoneOccupancyHeatmap({ yardId }: ZoneOccupancyHeatmapProps) {
+export function ZoneOccupancyHeatmap({ yardId, onZoneClick }: ZoneOccupancyHeatmapProps) {
   const { data: zones = [], isLoading } = useZoneOccupancy(yardId);
 
   if (isLoading) {
@@ -67,7 +69,15 @@ export function ZoneOccupancyHeatmap({ yardId }: ZoneOccupancyHeatmapProps) {
           const t = tone(z.occupancyPct);
           const pct = z.occupancyPct ?? 0;
           return (
-            <Card key={z.id} withBorder radius="md" padding="sm">
+            <Card
+              key={z.id}
+              withBorder
+              radius="md"
+              padding="sm"
+              onClick={onZoneClick ? () => onZoneClick(z) : undefined}
+              style={onZoneClick ? { cursor: 'pointer' } : undefined}
+              title={onZoneClick ? `View what is stored in ${z.name}` : undefined}
+            >
               <Stack gap={6}>
                 <Group justify="space-between" wrap="nowrap" gap="xs">
                   <Text fw={600} size="sm" truncate title={z.name}>
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/container-return-excel.test.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/container-return-excel.test.ts
new file mode 100644
index 000000000..48b23485d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/container-return-excel.test.ts
@@ -0,0 +1,75 @@
+import { describe, expect, it } from "vitest";
+import * as XLSX from "xlsx";
+
+import { parseContainerReturnExcel } from "./container-return-excel";
+
+/** Build an in-memory .xlsx and hand it back as a File, like the dropzone would. */
+function sheetFile(aoa: unknown[][]): File {
+  const wb = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(wb, XLSX.utils.aoa_to_sheet(aoa), "Sheet1");
+  const buf = XLSX.write(wb, { type: "array", bookType: "xlsx" }) as ArrayBuffer;
+  return new File([buf], "returns.xlsx");
+}
+
+const HEADERS = [
+  "Container Number",
+  "Container Size",
+  "Company",
+  "Returned By",
+  "Returned Date",
+  "Facility",
+  "Yard",
+  "Zone",
+  "Condition",
+  "Handover Note",
+];
+
+describe("parseContainerReturnExcel", () => {
+  it("parses a good sheet, normalizing size and returned-by", async () => {
+    const result = await parseContainerReturnExcel(
+      sheetFile([
+        ["Yard tally — August"], // title row above the header is ignored
+        HEADERS,
+        ["temu1234567", "40ft", "Acme PLC", "EDR last mile", "2026-08-14", "Gelan", "A", "1", "", ""],
+        ["MSCU7654321", "20", "Other Trading", "Self haul", "2026-08-15", "Gelan", "", "", "Dented", "n"],
+      ]),
+    );
+
+    expect(result.errors).toEqual([]);
+    expect(result.rows).toHaveLength(2);
+    expect(result.rows[0].containerNumber).toBe("TEMU1234567");
+    expect(result.rows[0].containerSize).toBe("40");
+    expect(result.rows[0].returnedBy).toBe("EDR");
+    expect(result.rows[0].companyName).toBe("Acme PLC");
+    expect(result.rows[0].returnDate?.startsWith("2026-08-14")).toBe(true);
+    expect(result.rows[1].containerSize).toBe("20");
+    expect(result.rows[1].returnedBy).toBe("CUSTOMER");
+  });
+
+  it("rejects the whole file when a container number is invalid", async () => {
+    const result = await parseContainerReturnExcel(
+      sheetFile([HEADERS, ["NOTACONTAINER", "40", "Acme", "EDR", "", "", "", "", "", ""]]),
+    );
+
+    expect(result.rows).toEqual([]);
+    expect(result.errors[0]).toContain("Row 2");
+  });
+
+  it("rejects duplicate container numbers", async () => {
+    const result = await parseContainerReturnExcel(
+      sheetFile([
+        HEADERS,
+        ["TEMU1234567", "40", "Acme", "EDR", "", "", "", "", "", ""],
+        ["temu1234567", "20", "Acme", "EDR", "", "", "", "", "", ""],
+      ]),
+    );
+
+    expect(result.rows).toEqual([]);
+    expect(result.errors.some((e) => e.includes("appears 2 times"))).toBe(true);
+  });
+
+  it("errors when there is no container-number column", async () => {
+    const result = await parseContainerReturnExcel(sheetFile([["Company", "Yard"], ["Acme", "A"]]));
+    expect(result.errors[0]).toContain("Container Number");
+  });
+});
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/container-return-excel.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/container-return-excel.ts
new file mode 100644
index 000000000..bdc29a13d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/container-return-excel.ts
@@ -0,0 +1,231 @@
+import * as XLSX from "xlsx";
+
+// Excel import for empties already sitting in an EDR yard that were never
+// entered in the system. One spreadsheet row per container. All-or-nothing —
+// any bad row rejects the whole file with row-numbered errors, so a partial
+// backfill can never silently drop boxes.
+
+// ISO 6346: 4-letter prefix (owner code + category id) + 7 digits.
+const ISO_CONTAINER_NUMBER_REGEX = /^[A-Z]{4}\d{7}$/;
+
+export interface ParsedReturnRow {
+  containerNumber: string;
+  containerSize: "20" | "40" | null;
+  companyName: string;
+  returnedBy: "EDR" | "CUSTOMER" | null;
+  returnDate: string | null;
+  facility: string;
+  yard: string;
+  zone: string;
+  condition: string;
+  handoverNote: string;
+}
+
+export interface ContainerReturnExcelResult {
+  rows: ParsedReturnRow[];
+  errors: string[];
+}
+
+type ColumnKey =
+  | "containerNumber"
+  | "containerSize"
+  | "companyName"
+  | "returnedBy"
+  | "returnDate"
+  | "facility"
+  | "yard"
+  | "zone"
+  | "condition"
+  | "handoverNote";
+
+/** Match a header cell to a known column, tolerant of casing/spacing/punctuation. */
+function headerKey(raw: string): ColumnKey | null {
+  const h = raw.toLowerCase().replace(/[^a-z]/g, "");
+  if (!h) return null;
+  if (h.includes("size") || h.includes("type")) return "containerSize";
+  if (h.includes("company") || h.includes("customer") || h.includes("consignee")) return "companyName";
+  if (h.includes("returnedby") || h.includes("haul") || h.includes("truck")) return "returnedBy";
+  if (h.includes("date")) return "returnDate";
+  if (h.includes("facility") || h.includes("warehouse") || h.includes("terminal")) return "facility";
+  if (h.includes("yard")) return "yard";
+  if (h.includes("zone")) return "zone";
+  if (h.includes("condition") || h.includes("damage")) return "condition";
+  if (h.includes("note") || h.includes("remark")) return "handoverNote";
+  // Least specific last, so "Container Size" is not eaten by "container".
+  if (h.includes("container") || h.includes("number")) return "containerNumber";
+  return null;
+}
+
+/** "20", "20ft", "40 HC" … → '20' | '40' | null. */
+function normalizeSize(raw: string): "20" | "40" | null {
+  const digits = raw.replace(/[^0-9]/g, "");
+  if (digits.startsWith("20")) return "20";
+  if (digits.startsWith("40") || digits.startsWith("45")) return "40";
+  return null;
+}
+
+/** "EDR", "EDR last mile", "customer", "self haul" … */
+function normalizeReturnedBy(raw: string): "EDR" | "CUSTOMER" | null {
+  const v = raw.toLowerCase();
+  if (!v.trim()) return null;
+  if (v.includes("edr")) return "EDR";
+  if (v.includes("customer") || v.includes("self")) return "CUSTOMER";
+  return null;
+}
+
+/**
+ * Excel dates arrive either as a serial number (raw cells) or as text. Returns
+ * an ISO instant, or null when the cell is empty/unparseable.
+ */
+function normalizeDate(raw: string): string | null {
+  const v = raw.trim();
+  if (!v) return null;
+  // Excel serial: days since 1899-12-30.
+  if (/^\d{1,6}(\.\d+)?$/.test(v)) {
+    const serial = Number(v);
+    if (serial > 20000 && serial < 80000) {
+      return new Date(Math.round((serial - 25569) * 86400000)).toISOString();
+    }
+  }
+  const parsed = new Date(v);
+  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+}
+
+/**
+ * Parse an uploaded workbook into one row per empty container. Returns either
+ * the full row set or the list of row-numbered problems — never both.
+ */
+export async function parseContainerReturnExcel(file: File): Promise<ContainerReturnExcelResult> {
+  let sheet: XLSX.WorkSheet | undefined;
+  try {
+    const workbook = XLSX.read(await file.arrayBuffer(), { type: "array" });
+    sheet = workbook.Sheets[workbook.SheetNames[0]];
+  } catch {
+    return { rows: [], errors: ["Could not read the file — is it a valid Excel file?"] };
+  }
+  if (!sheet) return { rows: [], errors: ["The file has no sheets."] };
+
+  const grid = XLSX.utils.sheet_to_json<string[]>(sheet, { header: 1, raw: false, defval: "" });
+
+  // First row carrying a container-number column is the header; titles and
+  // blank rows above it are ignored.
+  let headerRowIdx = -1;
+  let columns: Array<ColumnKey | null> = [];
+  for (let i = 0; i < grid.length; i++) {
+    const mapped = (grid[i] ?? []).map((c) => headerKey(String(c ?? "")));
+    if (mapped.includes("containerNumber")) {
+      headerRowIdx = i;
+      columns = mapped;
+      break;
+    }
+  }
+  if (headerRowIdx < 0) {
+    return {
+      rows: [],
+      errors: [
+        'Could not find a "Container Number" column — download the template to see the expected format.',
+      ],
+    };
+  }
+
+  const rows: ParsedReturnRow[] = [];
+  const errors: string[] = [];
+  const numberCounts = new Map<string, number>();
+
+  for (let i = headerRowIdx + 1; i < grid.length; i++) {
+    const cells = grid[i] ?? [];
+    if (cells.every((c) => String(c ?? "").trim() === "")) continue;
+    const rowNo = i + 1; // 1-based, as shown in Excel
+
+    const cell = (key: ColumnKey) => {
+      const idx = columns.indexOf(key);
+      return idx >= 0 ? String(cells[idx] ?? "").trim() : "";
+    };
+
+    const containerNumber = cell("containerNumber").toUpperCase().replace(/\s/g, "");
+    if (!ISO_CONTAINER_NUMBER_REGEX.test(containerNumber)) {
+      errors.push(
+        `Row ${rowNo}: "${cell("containerNumber") || "—"}" is not a valid ISO container number (e.g. TEMU1234567).`,
+      );
+    } else {
+      numberCounts.set(containerNumber, (numberCounts.get(containerNumber) ?? 0) + 1);
+    }
+
+    const sizeRaw = cell("containerSize");
+    const containerSize = sizeRaw ? normalizeSize(sizeRaw) : null;
+    if (sizeRaw && !containerSize) {
+      errors.push(`Row ${rowNo}: container size "${sizeRaw}" is not 20 or 40.`);
+    }
+
+    const returnedByRaw = cell("returnedBy");
+    const returnedBy = normalizeReturnedBy(returnedByRaw);
+    if (returnedByRaw && !returnedBy) {
+      errors.push(`Row ${rowNo}: returned by "${returnedByRaw}" must be EDR or CUSTOMER.`);
+    }
+
+    const dateRaw = cell("returnDate");
+    const returnDate = normalizeDate(dateRaw);
+    if (dateRaw && !returnDate) {
+      errors.push(`Row ${rowNo}: returned date "${dateRaw}" is not a date.`);
+    }
+
+    rows.push({
+      containerNumber,
+      containerSize,
+      companyName: cell("companyName"),
+      returnedBy,
+      returnDate,
+      facility: cell("facility"),
+      yard: cell("yard"),
+      zone: cell("zone"),
+      condition: cell("condition"),
+      handoverNote: cell("handoverNote"),
+    });
+  }
+
+  numberCounts.forEach((count, num) => {
+    if (count > 1) {
+      errors.push(`Container number ${num} appears ${count} times — numbers must be unique.`);
+    }
+  });
+
+  if (rows.length === 0 && errors.length === 0) {
+    errors.push("The sheet has no container rows below the header.");
+  }
+
+  return errors.length > 0 ? { rows: [], errors } : { rows, errors: [] };
+}
+
+/** Download the import template with one filled sample row. */
+export function downloadContainerReturnTemplate() {
+  const headers = [
+    "Container Number",
+    "Container Size",
+    "Company",
+    "Returned By",
+    "Returned Date",
+    "Facility",
+    "Yard",
+    "Zone",
+    "Condition",
+    "Handover Note",
+  ];
+  const sample = [
+    "TEMU1234567",
+    "40",
+    "Acme Import PLC",
+    "CUSTOMER",
+    new Date().toISOString().split("T")[0],
+    "Gelan Multipurpose port",
+    "Yard A",
+    "Zone 1",
+    "Sound",
+    "Backfilled from yard tally sheet",
+  ];
+
+  const sheet = XLSX.utils.aoa_to_sheet([headers, sample]);
+  sheet["!cols"] = headers.map((h) => ({ wch: Math.max(h.length + 2, 18) }));
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, sheet, "Container Returns");
+  XLSX.writeFile(workbook, "container-return-import-template.xlsx");
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/full-container-excel.test.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/full-container-excel.test.ts
new file mode 100644
index 000000000..107bf0f75
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/full-container-excel.test.ts
@@ -0,0 +1,87 @@
+import { describe, expect, it } from "vitest";
+import * as XLSX from "xlsx";
+
+import { parseFullContainerExcel } from "./full-container-excel";
+
+function sheetFile(aoa: unknown[][]): File {
+  const wb = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(wb, XLSX.utils.aoa_to_sheet(aoa), "Sheet1");
+  const buf = XLSX.write(wb, { type: "array", bookType: "xlsx" }) as ArrayBuffer;
+  return new File([buf], "backlog.xlsx");
+}
+
+const HEADERS = [
+  "Container Number",
+  "Container Size",
+  "Company",
+  "Arrival Date",
+  "Facility",
+  "Yard",
+  "Zone",
+  "Seal Number",
+  "Weight (Tons)",
+  "Notes",
+];
+
+const row = (num: string, arrived: string, weight: string | number = 24.5) => [
+  num,
+  "40",
+  "Acme PLC",
+  arrived,
+  "Gelan",
+  "A",
+  "1",
+  "SL1",
+  weight,
+  "",
+];
+
+describe("parseFullContainerExcel", () => {
+  it("parses a backlog sheet with past arrival dates", async () => {
+    const result = await parseFullContainerExcel(
+      sheetFile([HEADERS, row("temu1234567", "2026-03-14"), row("MSCU7654321", "2025-11-02")]),
+    );
+
+    expect(result.errors).toEqual([]);
+    expect(result.rows).toHaveLength(2);
+    expect(result.rows[0].containerNumber).toBe("TEMU1234567");
+    expect(result.rows[0].arrivedAt?.startsWith("2026-03-14")).toBe(true);
+    expect(result.rows[0].companyName).toBe("Acme PLC");
+  });
+
+  it("rejects a future arrival date — a backlog box arrived in the past", async () => {
+    const future = new Date();
+    future.setFullYear(future.getFullYear() + 1);
+    const result = await parseFullContainerExcel(
+      sheetFile([HEADERS, row("TEMU1234567", future.toISOString().slice(0, 10))]),
+    );
+
+    expect(result.rows).toEqual([]);
+    expect(result.errors.some((e) => e.includes("in the future"))).toBe(true);
+  });
+
+  it("accepts an arrival date of today", async () => {
+    const today = new Date().toISOString().slice(0, 10);
+    const result = await parseFullContainerExcel(sheetFile([HEADERS, row("TEMU1234567", today)]));
+    expect(result.errors).toEqual([]);
+  });
+
+  it("rejects an invalid container number and a negative weight", async () => {
+    const result = await parseFullContainerExcel(
+      sheetFile([HEADERS, row("NOPE", "2026-03-14"), row("MSCU7654321", "2026-03-14", -3)]),
+    );
+
+    expect(result.rows).toEqual([]);
+    expect(result.errors.some((e) => e.includes("ISO container number"))).toBe(true);
+    expect(result.errors.some((e) => e.includes("0 or more"))).toBe(true);
+  });
+
+  it("rejects duplicate container numbers", async () => {
+    const result = await parseFullContainerExcel(
+      sheetFile([HEADERS, row("TEMU1234567", "2026-03-14"), row("temu1234567", "2026-03-15")]),
+    );
+
+    expect(result.rows).toEqual([]);
+    expect(result.errors.some((e) => e.includes("appears 2 times"))).toBe(true);
+  });
+});
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/full-container-excel.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/full-container-excel.ts
new file mode 100644
index 000000000..f94057383
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/full-container-excel.ts
@@ -0,0 +1,206 @@
+import * as XLSX from "xlsx";
+
+// Excel import for loaded containers already sitting in a yard but never
+// entered in the system. One row per container. All-or-nothing — any bad row
+// rejects the file with row-numbered errors, so a half-registered yard cannot
+// happen.
+
+const ISO_CONTAINER_NUMBER_REGEX = /^[A-Z]{4}\d{7}$/;
+
+export interface ParsedFullContainerRow {
+  containerNumber: string;
+  containerSize: string;
+  companyName: string;
+  /** ISO instant; null when the cell was empty or unreadable. */
+  arrivedAt: string | null;
+  facility: string;
+  yard: string;
+  zone: string;
+  sealNumber: string;
+  weight: string;
+  notes: string;
+}
+
+export interface FullContainerExcelResult {
+  rows: ParsedFullContainerRow[];
+  errors: string[];
+}
+
+type ColumnKey =
+  | "containerNumber"
+  | "containerSize"
+  | "companyName"
+  | "arrivedAt"
+  | "facility"
+  | "yard"
+  | "zone"
+  | "sealNumber"
+  | "weight"
+  | "notes";
+
+/** Match a header cell to a known column, tolerant of casing/spacing/punctuation. */
+function headerKey(raw: string): ColumnKey | null {
+  const h = raw.toLowerCase().replace(/[^a-z]/g, "");
+  if (!h) return null;
+  if (h.includes("seal")) return "sealNumber";
+  if (h.includes("size") || h.includes("type")) return "containerSize";
+  if (h.includes("company") || h.includes("owner") || h.includes("consignee")) return "companyName";
+  if (h.includes("arriv") || h.includes("date")) return "arrivedAt";
+  if (h.includes("facility") || h.includes("warehouse") || h.includes("terminal")) return "facility";
+  if (h.includes("yard")) return "yard";
+  if (h.includes("zone")) return "zone";
+  if (h.includes("weight") || h.includes("vgm")) return "weight";
+  if (h.includes("note") || h.includes("remark")) return "notes";
+  if (h.includes("container") || h.includes("number")) return "containerNumber";
+  return null;
+}
+
+/**
+ * Excel dates arrive either as a serial number (raw cells) or as text.
+ * Returns an ISO instant, or null when the cell is empty/unparseable.
+ */
+function normalizeDate(raw: string): string | null {
+  const v = raw.trim();
+  if (!v) return null;
+  if (/^\d{1,6}(\.\d+)?$/.test(v)) {
+    const serial = Number(v);
+    if (serial > 20000 && serial < 80000) {
+      return new Date(Math.round((serial - 25569) * 86400000)).toISOString();
+    }
+  }
+  const parsed = new Date(v);
+  return Number.isNaN(parsed.getTime()) ? null : parsed.toISOString();
+}
+
+/** Parse an uploaded workbook into one row per loaded container. */
+export async function parseFullContainerExcel(file: File): Promise<FullContainerExcelResult> {
+  let sheet: XLSX.WorkSheet | undefined;
+  try {
+    const workbook = XLSX.read(await file.arrayBuffer(), { type: "array" });
+    sheet = workbook.Sheets[workbook.SheetNames[0]];
+  } catch {
+    return { rows: [], errors: ["Could not read the file — is it a valid Excel file?"] };
+  }
+  if (!sheet) return { rows: [], errors: ["The file has no sheets."] };
+
+  const grid = XLSX.utils.sheet_to_json<string[]>(sheet, { header: 1, raw: false, defval: "" });
+
+  let headerRowIdx = -1;
+  let columns: Array<ColumnKey | null> = [];
+  for (let i = 0; i < grid.length; i++) {
+    const mapped = (grid[i] ?? []).map((c) => headerKey(String(c ?? "")));
+    if (mapped.includes("containerNumber")) {
+      headerRowIdx = i;
+      columns = mapped;
+      break;
+    }
+  }
+  if (headerRowIdx < 0) {
+    return {
+      rows: [],
+      errors: [
+        'Could not find a "Container Number" column — download the template to see the expected format.',
+      ],
+    };
+  }
+
+  const rows: ParsedFullContainerRow[] = [];
+  const errors: string[] = [];
+  const numberCounts = new Map<string, number>();
+  const startOfTomorrow = new Date();
+  startOfTomorrow.setHours(24, 0, 0, 0);
+
+  for (let i = headerRowIdx + 1; i < grid.length; i++) {
+    const cells = grid[i] ?? [];
+    if (cells.every((c) => String(c ?? "").trim() === "")) continue;
+    const rowNo = i + 1; // 1-based, as shown in Excel
+
+    const cell = (key: ColumnKey) => {
+      const idx = columns.indexOf(key);
+      return idx >= 0 ? String(cells[idx] ?? "").trim() : "";
+    };
+
+    const containerNumber = cell("containerNumber").toUpperCase().replace(/\s/g, "");
+    if (!ISO_CONTAINER_NUMBER_REGEX.test(containerNumber)) {
+      errors.push(
+        `Row ${rowNo}: "${cell("containerNumber") || "—"}" is not a valid ISO container number (e.g. TEMU1234567).`,
+      );
+    } else {
+      numberCounts.set(containerNumber, (numberCounts.get(containerNumber) ?? 0) + 1);
+    }
+
+    const arrivedRaw = cell("arrivedAt");
+    const arrivedAt = normalizeDate(arrivedRaw);
+    if (arrivedRaw && !arrivedAt) {
+      errors.push(`Row ${rowNo}: arrival date "${arrivedRaw}" is not a date.`);
+    }
+    // The whole point of a backlog is that it arrived in the past.
+    if (arrivedAt && new Date(arrivedAt).getTime() >= startOfTomorrow.getTime()) {
+      errors.push(`Row ${rowNo}: arrival date "${arrivedRaw}" is in the future.`);
+    }
+
+    const weightRaw = cell("weight");
+    if (weightRaw && (Number.isNaN(Number(weightRaw)) || Number(weightRaw) < 0)) {
+      errors.push(`Row ${rowNo}: weight "${weightRaw}" must be a number of 0 or more.`);
+    }
+
+    rows.push({
+      containerNumber,
+      containerSize: cell("containerSize"),
+      companyName: cell("companyName"),
+      arrivedAt,
+      facility: cell("facility"),
+      yard: cell("yard"),
+      zone: cell("zone"),
+      sealNumber: cell("sealNumber"),
+      weight: weightRaw,
+      notes: cell("notes"),
+    });
+  }
+
+  numberCounts.forEach((count, num) => {
+    if (count > 1) {
+      errors.push(`Container number ${num} appears ${count} times — numbers must be unique.`);
+    }
+  });
+
+  if (rows.length === 0 && errors.length === 0) {
+    errors.push("The sheet has no container rows below the header.");
+  }
+
+  return errors.length > 0 ? { rows: [], errors } : { rows, errors: [] };
+}
+
+/** Download the import template with one filled sample row. */
+export function downloadFullContainerTemplate() {
+  const headers = [
+    "Container Number",
+    "Container Size",
+    "Company",
+    "Arrival Date",
+    "Facility",
+    "Yard",
+    "Zone",
+    "Seal Number",
+    "Weight (Tons)",
+    "Notes",
+  ];
+  const sample = [
+    "TEMU1234567",
+    "40",
+    "Acme Import PLC",
+    "2026-03-14",
+    "Gelan Multipurpose port",
+    "Yard A",
+    "Zone 1",
+    "SL482910",
+    24.5,
+    "Backlog — registered from yard tally sheet",
+  ];
+
+  const sheet = XLSX.utils.aoa_to_sheet([headers, sample]);
+  sheet["!cols"] = headers.map((h) => ({ wch: Math.max(h.length + 2, 18) }));
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, sheet, "Full Containers");
+  XLSX.writeFile(workbook, "full-container-backlog-template.xlsx");
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
index dae0e1d7f..4e0ebd7f8 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/index.ts
@@ -9,6 +9,9 @@ export { WarehouseInquiryTable } from './WarehouseInquiryTable';
 export { CreateWarehouseModal } from './CreateWarehouseModal';
 export { CreateYardModal } from './CreateYardModal';
 export { CreateZoneModal } from './CreateZoneModal';
+export { ZoneContentsModal, type ZoneRef } from './ZoneContentsModal';
+export { ZoneLayoutModal } from './ZoneLayoutModal';
+export { SlotPicker } from './SlotPicker';
 export { ReceiveInventoryModal, WarehouseFlowWorkbench } from './ReceiveInventoryModal';
 export { WarehouseInfoCard } from './WarehouseInfoCard';
 export { MoveInventoryModal } from './MoveInventoryModal';
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
index 5fd393268..eecf5809f 100644
--- a/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/options.ts
@@ -1,4 +1,5 @@
 import {
+  WAREHOUSE_FREIGHT_TYPES,
   WAREHOUSE_TYPES,
   WAREHOUSE_YARD_TYPES,
   WAREHOUSE_ZONE_TYPES,
@@ -73,6 +74,7 @@ export const yardsForBooking = (
 };
 
 export const warehouseTypeOptions = toOptions(WAREHOUSE_TYPES);
+export const warehouseFreightTypeOptions = toOptions(WAREHOUSE_FREIGHT_TYPES);
 export const yardTypeOptions = toOptions(WAREHOUSE_YARD_TYPES);
 export const zoneTypeOptions = toOptions(WAREHOUSE_ZONE_TYPES);
 export const statusOptions = toOptions(WAREHOUSE_STATUSES);
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/slot-picker.test.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/slot-picker.test.ts
new file mode 100644
index 000000000..ea2cbd984
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/slot-picker.test.ts
@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+
+import { fillableLevels } from './SlotPicker';
+import type { SlotEffectiveStatus, ZoneLayout } from '@/types/warehouse';
+
+/**
+ * The picker must offer only positions the API will accept, or the operator
+ * gets a 400 for a level the form itself suggested.
+ */
+function layout(
+  stacks: Array<{
+    code: string;
+    height?: number;
+    isActive?: boolean;
+    levels: SlotEffectiveStatus[];
+  }>,
+): ZoneLayout {
+  return {
+    zoneId: 'zone-1',
+    zoneCode: 'L1-O-A-ZA',
+    zoneName: 'Zone A',
+    summary: {
+      configuredCapacity: 60,
+      physicalSlotCount: 60,
+      occupiedSlotCount: 0,
+      reservedSlotCount: 0,
+      blockedSlotCount: 0,
+      inactiveSlotCount: 0,
+      availableSlotCount: 60,
+      inconsistent: false,
+    },
+    stacks: stacks.map((stack) => ({
+      stackId: `id-${stack.code}`,
+      code: stack.code,
+      name: null,
+      maxStackHeight: stack.height ?? 3,
+      status: stack.isActive === false ? 'INACTIVE' : 'ACTIVE',
+      isActive: stack.isActive !== false,
+      // The API returns the highest level first — mirror that here.
+      slots: stack.levels
+        .map((effectiveStatus, index) => ({
+          slotId: `${stack.code}-L${index + 1}`,
+          level: index + 1,
+          effectiveStatus,
+          inventoryId: effectiveStatus === 'OCCUPIED' ? `inv-${stack.code}-${index + 1}` : null,
+          containerNumber: null,
+        }))
+        .reverse(),
+    })),
+  };
+}
+
+describe('SlotPicker.fillableLevels', () => {
+  it('offers the ground level of an empty stack', () => {
+    const options = fillableLevels(layout([{ code: 'ZA-001', levels: ['AVAILABLE', 'AVAILABLE', 'AVAILABLE'] }]));
+    expect(options).toEqual([{ value: 'ZA-001-L1', label: 'ZA-001 — level 1 (ground)' }]);
+  });
+
+  it('offers only the level directly above the top container', () => {
+    const options = fillableLevels(layout([{ code: 'ZA-001', levels: ['OCCUPIED', 'AVAILABLE', 'AVAILABLE'] }]));
+    expect(options).toEqual([{ value: 'ZA-001-L2', label: 'ZA-001 — level 2 (on 1 container)' }]);
+  });
+
+  it('never offers a level that would float over an empty one', () => {
+    const options = fillableLevels(layout([{ code: 'ZA-001', levels: ['OCCUPIED', 'OCCUPIED', 'AVAILABLE'] }]));
+    expect(options.map((o) => o.value)).toEqual(['ZA-001-L3']);
+  });
+
+  it('drops a full stack', () => {
+    expect(fillableLevels(layout([{ code: 'ZA-001', levels: ['OCCUPIED', 'OCCUPIED', 'OCCUPIED'] }]))).toEqual([]);
+  });
+
+  it('drops a stack whose next level is blocked or reserved', () => {
+    expect(fillableLevels(layout([{ code: 'ZA-001', levels: ['BLOCKED', 'AVAILABLE', 'AVAILABLE'] }]))).toEqual([]);
+    expect(fillableLevels(layout([{ code: 'ZA-002', levels: ['RESERVED', 'AVAILABLE', 'AVAILABLE'] }]))).toEqual([]);
+  });
+
+  it('drops an inactive stack', () => {
+    expect(
+      fillableLevels(layout([{ code: 'ZA-001', isActive: false, levels: ['AVAILABLE', 'AVAILABLE', 'AVAILABLE'] }])),
+    ).toEqual([]);
+  });
+
+  it('lists one position per stack across the zone', () => {
+    const options = fillableLevels(
+      layout([
+        { code: 'ZA-001', levels: ['OCCUPIED', 'AVAILABLE', 'AVAILABLE'] },
+        { code: 'ZA-002', levels: ['AVAILABLE', 'AVAILABLE', 'AVAILABLE'] },
+      ]),
+    );
+    expect(options.map((o) => o.value)).toEqual(['ZA-001-L2', 'ZA-002-L1']);
+  });
+
+  it('returns nothing before the layout has loaded', () => {
+    expect(fillableLevels(undefined)).toEqual([]);
+  });
+});
diff --git a/apps/edr-freight-web/backoffice/src/components/warehouses/useCompanyOptions.ts b/apps/edr-freight-web/backoffice/src/components/warehouses/useCompanyOptions.ts
new file mode 100644
index 000000000..2c80535b7
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/warehouses/useCompanyOptions.ts
@@ -0,0 +1,37 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { customersService } from "@/services/customers.service";
+
+/**
+ * Registered customer companies, as Autocomplete options. The picker is an
+ * Autocomplete rather than a Select on purpose: a company that is not on the
+ * system yet is typed in, and only the name is kept.
+ */
+export function useCompanyOptions() {
+  const { data, isLoading } = useQuery({
+    queryKey: ["companies-autocomplete"],
+    queryFn: () => customersService.list({ page: 1, pageSize: 1000 }),
+    staleTime: 5 * 60 * 1000,
+  });
+
+  const companies = data?.items ?? [];
+
+  // Company names are not unique — Mantine throws on duplicate option values,
+  // so the list is deduped by the trimmed name.
+  const names = [...new Set(companies.map((c) => c.name.trim()).filter(Boolean))];
+
+  return {
+    loading: isLoading,
+    names,
+    /**
+     * Name → company id, only when exactly one company carries that name. An
+     * ambiguous name resolves to nothing rather than to an arbitrary company:
+     * the container keeps the typed name and no wrong customer is attached.
+     */
+    resolveId: (name: string): string | undefined => {
+      const key = name.trim().toLowerCase();
+      const matches = companies.filter((c) => c.name.trim().toLowerCase() === key);
+      return matches.length === 1 ? matches[0].id : undefined;
+    },
+  };
+}
diff --git a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
index 66a55b555..0ee03a626 100644
--- a/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/QUERY_KEYS.ts
@@ -161,6 +161,8 @@ export const QUERY_KEYS = {
       ["train-scheduling", "schedules", filters ?? {}] as const,
     scheduleById: (id: string) => ["train-scheduling", "schedule", id] as const,
     track: (id: string) => ["train-scheduling", "track", id] as const,
+    marshallingStops: (id: string) =>
+      ["train-scheduling", "marshalling-stops", id] as const,
     batchBoard: (filters?: unknown) =>
       ["train-scheduling", "batch-board", "list", filters ?? {}] as const,
     batchBoardDetail: (scheduleId: string) =>
diff --git a/apps/edr-freight-web/backoffice/src/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index 3fc6e53c0..32eb6b798 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -537,6 +537,10 @@ export const URL_CONSTANTS = {
       `/train-scheduling/schedules/${id}/export/load-list/document`,
     INTERCITY_MARSHALLING_DOCUMENT: (id: string) =>
       `/train-scheduling/schedules/${id}/intercity/marshalling/document`,
+    MARSHALLING_STOPS: (id: string) =>
+      `/train-scheduling/schedules/${id}/marshalling/stops`,
+    MARSHALLING_DOCUMENT_AT: (id: string, stopIndex: number) =>
+      `/train-scheduling/schedules/${id}/marshalling/document/${stopIndex}`,
     CHECKPOINTS: (id: string) =>
       `/train-scheduling/schedules/${id}/checkpoints`,
     CHECKPOINT: (id: string, sequenceNo: number) =>
@@ -648,6 +652,16 @@ export const URL_CONSTANTS = {
   WAREHOUSE_ZONES: {
     BASE: "/warehouse-zones",
     BY_ID: (id: string) => `/warehouse-zones/${id}`,
+    LAYOUT: (id: string) => `/warehouse-zones/${id}/layout`,
+    SLOT_SUMMARY: (id: string) => `/warehouse-zones/${id}/slot-summary`,
+  },
+
+  WAREHOUSE_ZONE_STACKS: {
+    BASE: "/warehouse-zone-stacks",
+    BY_ZONE: (zoneId: string) => `/warehouse-zone-stacks?zoneId=${zoneId}`,
+    BY_ID: (id: string) => `/warehouse-zone-stacks/${id}`,
+    OCCUPANCY: (id: string) => `/warehouse-zone-stacks/${id}/occupancy`,
+    SLOT: (slotId: string) => `/warehouse-zone-stacks/slots/${slotId}`,
   },
 
   WAREHOUSE_INVENTORY: {
@@ -662,6 +676,10 @@ export const URL_CONSTANTS = {
     LOAD: (id: string) => `/warehouse-inventory/${id}/load`,
     DISPATCH: (id: string) => `/warehouse-inventory/${id}/dispatch`,
     MOVE: (id: string) => `/warehouse-inventory/${id}/move`,
+    FIND_SLOT: "/warehouse-inventory/placement/find-slot",
+    ASSIGN_SLOT: (id: string) => `/warehouse-inventory/${id}/assign-slot`,
+    RELEASE_SLOT: (id: string) => `/warehouse-inventory/${id}/release-slot`,
+    ACCESSIBILITY: (id: string) => `/warehouse-inventory/${id}/accessibility`,
     RESERVE: "/warehouse-inventory/reserve",
     ARRIVAL_QUEUE: "/warehouse-inventory/arrival-queue",
     OPS_STATS: "/warehouse-inventory/ops-stats",
@@ -703,6 +721,8 @@ export const URL_CONSTANTS = {
         ? `/warehouse-inventory/eligible-bookings?direction=${direction}`
         : `/warehouse-inventory/eligible-bookings`,
     RECEIVE_BULK: "/warehouse-inventory/receive-bulk",
+    REGISTER_BACKLOG: "/warehouse-inventory/register-backlog",
+    REGISTER_BACKLOG_BULK: "/warehouse-inventory/register-backlog-bulk",
     LOAD_PASSED_EXPORT: "/warehouse-inventory/load-passed-export",
     BULK_MARK_INSPECTED: "/warehouse-inventory/bulk-mark-inspected",
     RECEIVED_EXPORT: "/warehouse-inventory/received-export",
@@ -791,6 +811,7 @@ export const URL_CONSTANTS = {
     CUSTOMS_RELEASE_PERMITTED: (bookingId: string) =>
       `/import-operations/customs/${bookingId}/release-permitted`,
     EMPTY_CONTAINER_RETURNS: "/import-operations/empty-container-returns",
+    EMPTY_CONTAINER_RETURNS_BULK: "/import-operations/empty-container-returns/bulk",
     EMPTY_CONTAINER_RETURN_STATUS: (id: string) =>
       `/import-operations/empty-container-returns/${id}/status`,
     EMPTY_CONTAINER_RETURNS_LOAD_ON_TRAIN:
diff --git a/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts b/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
index bf19542b4..6ed13636a 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/useWarehouses.ts
@@ -82,6 +82,14 @@ export function useUpdateWarehouse() {
   });
 }
 
+export function useDeleteWarehouse() {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (id: string) => warehouseService.remove(id),
+    onSuccess: () => qc.invalidateQueries({ queryKey: warehouseKeys.all }),
+  });
+}
+
 // ── Yards ────────────────────────────────────────────────────────────────
 
 export function useWarehouseYards(warehouseId?: string) {
diff --git a/apps/edr-freight-web/backoffice/src/lib/format.ts b/apps/edr-freight-web/backoffice/src/lib/format.ts
index 4c5c6b639..1c8e66bb3 100644
--- a/apps/edr-freight-web/backoffice/src/lib/format.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/format.ts
@@ -60,3 +60,10 @@ export function formatBytes(bytes: number): string {
   const value = bytes / Math.pow(1024, i);
   return `${value.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
 }
+
+/** `YYYY-MM-DDTHH:mm` for now, in local time — what `datetime-local` expects. */
+export function localNowForInput(): string {
+  const d = new Date();
+  d.setMinutes(d.getMinutes() - d.getTimezoneOffset());
+  return d.toISOString().slice(0, 16);
+}
diff --git a/apps/edr-freight-web/backoffice/src/lib/permissions.ts b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
index b3d721eb5..38af63785 100644
--- a/apps/edr-freight-web/backoffice/src/lib/permissions.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
@@ -307,6 +307,7 @@ export const FREIGHT_PERMS = {
     view: "edr_freight_app:warehouse_zones:view",
     create: "edr_freight_app:warehouse_zones:create",
     update: "edr_freight_app:warehouse_zones:update",
+    delete: "edr_freight_app:warehouse_zones:delete",
   },
   warehouseAllocationRules: {
     view: "edr_freight_app:warehouse_allocation_rules:view",
diff --git a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
index 758f8a7bb..a277d0570 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestsPage.tsx
@@ -140,6 +140,25 @@ export default function BookingRequestsPage() {
     [refData],
   );
 
+  // Content options mirror the booking wizard's cargo picker: the group itself
+  // — which the server expands to every commodity beneath it — then each
+  // commodity, labelled by its full path so a generically-named leaf still
+  // reads unambiguously. A group with no descendants is emitted by the
+  // reference-data tree as its own single child; drop that duplicate.
+  const cargoTypeOptions = useMemo(
+    () =>
+      (refData?.cargo_type ?? []).flatMap((group) => [
+        { value: group.id, label: group.name },
+        ...(group.children ?? [])
+          .filter((child) => child.id !== group.id)
+          .map((child) => ({
+            value: child.id,
+            label: `${group.name} → ${child.name}`,
+          })),
+      ]),
+    [refData],
+  );
+
   // Deep links land here pre-filtered (?statuses=A,B&tradeDirection=IMPORT) —
   // the header's document-review alarm opens exactly the undecided requests
   // it is counting down for. No sync effect needed any more: controls.values
@@ -147,6 +166,15 @@ export default function BookingRequestsPage() {
   // already mounted just works, and every filter — direction included —
   // auto-pins its own pill the moment it has a value (FilterBar's `secondary`
   // split), so a deep link can never land behind "More filters" unseen.
+  // Container types, flattened out of the reference data's size groups.
+  const containerTypeOptions = useMemo(
+    () =>
+      (refData?.containers ?? []).flatMap((group) =>
+        group.types.map((t) => ({ value: t.id, label: t.name || t.code })),
+      ),
+    [refData],
+  );
+
   const bookingFilterDefs: FilterDef[] = useMemo(
     () => [
       {
@@ -183,6 +211,65 @@ export default function BookingRequestsPage() {
         multiple: false,
         options: FREIGHT_TYPE_OPTIONS,
       },
+      {
+        // Cargo group or commodity. The group row matches its whole subtree
+        // server-side, so "Bulk" returns every bulk commodity under it.
+        key: "cargoTypeId",
+        label: "Content",
+        type: "enum",
+        multiple: false,
+        options: cargoTypeOptions,
+      },
+      {
+        // Containers carry no customer-written description, so this is also how
+        // they are reached: it matches container types ("40FT") as well as the
+        // commodity name and the bulk cargo description.
+        key: "cargoText",
+        label: "Content contains",
+        type: "text",
+        secondary: true,
+        placeholder: "Commodity, description or container type",
+      },
+      {
+        key: "containerTypeId",
+        label: "Container type",
+        type: "enum",
+        multiple: false,
+        options: containerTypeOptions,
+        secondary: true,
+      },
+      {
+        // Counts boxes. Scoped to the container-type filter when one is set, so
+        // this one control answers "10 containers" and "10 forty-footers" both.
+        key: "containers",
+        label: "Containers",
+        type: "number",
+        secondary: true,
+        operators: ["is", "between"],
+        toParams: (v) =>
+          v.op === "between"
+            ? { containersMin: v.v[0], containersMax: v.v[1] }
+            : { containersMin: v.v[0], containersMax: v.v[0] },
+      },
+      {
+        // Declared on the shipment request, not yet on the booking. Pair it
+        // with Containers = 0 to find the set awaiting completion.
+        key: "requestedContainers",
+        label: "Requested containers",
+        type: "number",
+        secondary: true,
+        operators: ["is", "between"],
+        toParams: (v) =>
+          v.op === "between"
+            ? {
+                requestedContainersMin: v.v[0],
+                requestedContainersMax: v.v[1],
+              }
+            : {
+                requestedContainersMin: v.v[0],
+                requestedContainersMax: v.v[0],
+              },
+      },
       {
         key: "serviceTypeId",
         label: "Service",
@@ -244,7 +331,13 @@ export default function BookingRequestsPage() {
         toParams: dateRangeParams("scheduledFrom", "scheduledTo"),
       },
     ],
-    [filterOptions, yardOptions, serviceTypeOptions],
+    [
+      filterOptions,
+      yardOptions,
+      serviceTypeOptions,
+      cargoTypeOptions,
+      containerTypeOptions,
+    ],
   );
 
   const controls = useFilters(bookingFilterDefs, {
diff --git a/apps/edr-freight-web/backoffice/src/pages/invoices/InvoicesPage.tsx b/apps/edr-freight-web/backoffice/src/pages/invoices/InvoicesPage.tsx
index 8b28fd71a..2b319de30 100644
--- a/apps/edr-freight-web/backoffice/src/pages/invoices/InvoicesPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/invoices/InvoicesPage.tsx
@@ -19,8 +19,10 @@ import { ExportButton } from "@/components/export/ExportButton";
 import { useExchangeSettingsQuery } from "@/hooks/useExchangeSettings";
 import { api } from "@/services/api";
 import {
+  INVOICE_TYPE_OPTIONS,
   PAYMENT_METHOD_OPTIONS,
   invoicePaymentMethod,
+  invoiceTypeLabel,
   paymentMethodLabel,
   type Invoice,
   type InvoiceListFilter,
@@ -55,6 +57,7 @@ const EIMS_STATUS_OPTIONS = [
 const INVOICE_FILTER_DEFS: FilterDef[] = [
   { key: "statuses", label: "Status", type: "enum", options: STATUS_OPTIONS },
   { key: "sources", label: "Source", type: "enum", options: SOURCE_OPTIONS },
+  { key: "types", label: "Type", type: "enum", options: INVOICE_TYPE_OPTIONS },
   {
     key: "currency",
     label: "Currency",
@@ -261,6 +264,15 @@ export default function InvoicesPanel() {
         size: 220,
         cell: ({ row }) => <InvoiceSourceCell invoice={row.original} />,
       },
+      {
+        id: "type",
+        header: "Type",
+        cell: ({ row }) => (
+          <Text size="sm" c="edr-text" truncate maw={180}>
+            {invoiceTypeLabel(row.original.type)}
+          </Text>
+        ),
+      },
       {
         id: "status",
         header: "Status",
@@ -389,7 +401,7 @@ export default function InvoicesPanel() {
           </Box>
 
           <Box style={{ overflowX: "auto" }} w="100%">
-            <Box miw={1040}>
+            <Box miw={1200}>
               <DataTable
                 columns={columns}
                 data={rows}
diff --git a/apps/edr-freight-web/backoffice/src/pages/invoices/UsdPaymentsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/invoices/UsdPaymentsPage.tsx
index 8bb142862..8b3e58a5f 100644
--- a/apps/edr-freight-web/backoffice/src/pages/invoices/UsdPaymentsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/invoices/UsdPaymentsPage.tsx
@@ -44,7 +44,9 @@ import { useManualPaymentSettingsQuery } from "@/hooks/useManualPaymentSettings"
 import { FREIGHT_PERMS, hasPermission } from "@/lib/permissions";
 import { api } from "@/services/api";
 import {
+  INVOICE_TYPE_OPTIONS,
   PAYMENT_METHOD_OPTIONS,
+  invoiceTypeLabel,
   type InvoiceListFilter,
   type OfflineUsdInvoice,
 } from "@/types/invoice";
@@ -109,6 +111,13 @@ const MANUAL_PAYMENT_FILTER_DEFS: FilterDef[] = [
     secondary: true,
     options: SOURCE_OPTIONS,
   },
+  {
+    key: "types",
+    label: "Type",
+    type: "enum",
+    secondary: true,
+    options: INVOICE_TYPE_OPTIONS,
+  },
   {
     key: "paymentMethods",
     label: "Payment method",
@@ -424,6 +433,15 @@ export default function UsdPaymentsPanel({
           );
         },
       },
+      {
+        id: "type",
+        header: "Type",
+        cell: ({ row }) => (
+          <Text size="sm" c="edr-text" truncate maw={180}>
+            {invoiceTypeLabel(row.original.type)}
+          </Text>
+        ),
+      },
       {
         id: "status",
         header: "Status",
@@ -523,7 +541,7 @@ export default function UsdPaymentsPanel({
           </Box>
 
           <Box style={{ overflowX: "auto" }} w="100%">
-            <Box miw={1160}>
+            <Box miw={1320}>
               <DataTable
                 columns={columns}
                 data={rows}
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx
index 3d74c0fb5..2b1961362 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleTrackPage.tsx
@@ -15,7 +15,7 @@ import {
   Route,
   TrainFront,
 } from "lucide-react";
-import { Box, Button, Group, Loader, Stack, Text } from "@mantine/core";
+import { Box, Button, Group, Loader, Menu, Stack, Text } from "@mantine/core";
 
 import { CheckpointTimeModal } from "@/components/trainScheduling/CheckpointTimeModal";
 import { CheckpointLogTable } from "@/components/trainScheduling/CheckpointLogTable";
@@ -119,18 +119,34 @@ export default function TrainScheduleTrackPage() {
       enabled: Boolean(scheduleId) && trackQuery.data?.status === "DISPATCHED",
     }),
   );
-  // Marshalling 2: the current on-board list, reprinted after station work.
+  // Marshalling: the on-board list, reprinted after station work. Numbered
+  // per corridor stop that actually coupled/uncoupled something (Marshalling
+  // 2, 3, 4…) — falls back to the single "current position" doc when nothing
+  // has happened yet.
+  const marshallingStopsQuery = useQuery(
+    api.trainScheduling.marshallingStops.queryOptions({
+      input: { id: scheduleId ?? "" },
+      enabled:
+        Boolean(scheduleId) &&
+        ["DISPATCHED", "ARRIVED"].includes(trackQuery.data?.status ?? ""),
+    }),
+  );
+  const marshallingStops = marshallingStopsQuery.data ?? [];
   const intercityMarshalling = useMutation({
-    mutationFn: () =>
-      trainSchedulingService.downloadIntercityMarshallingDocument(scheduleId ?? ""),
+    mutationFn: (stopIndex?: number) =>
+      stopIndex != null
+        ? trainSchedulingService.downloadMarshallingDocumentAt(scheduleId ?? "", stopIndex)
+        : trainSchedulingService.downloadIntercityMarshallingDocument(scheduleId ?? ""),
   });
-  const openIntercityMarshalling = async () => {
+  const openIntercityMarshalling = async (stopIndex?: number) => {
     const pdfWindow = window.open("", "_blank");
     try {
-      const blob = await intercityMarshalling.mutateAsync();
-      const opened = openPdfBlob(blob, `intercity-marshalling-${scheduleId}.pdf`, pdfWindow);
+      const blob = await intercityMarshalling.mutateAsync(stopIndex);
+      const filename =
+        stopIndex != null ? `marshalling-${stopIndex}-${scheduleId}.pdf` : `intercity-marshalling-${scheduleId}.pdf`;
+      const opened = openPdfBlob(blob, filename, pdfWindow);
       toast({
-        title: "Intercity marshalling ready",
+        title: stopIndex != null ? `Marshalling ${stopIndex} ready` : "Intercity marshalling ready",
         description: opened
           ? "The PDF opened in a browser tab for printing or saving."
           : "The browser blocked the preview tab, so the PDF was downloaded.",
@@ -313,7 +329,7 @@ export default function TrainScheduleTrackPage() {
           </Text>
         </Group>
         <Box style={{ flex: 1 }} />
-        {inTransit || arrived ? (
+        {(inTransit || arrived) && marshallingStops.length === 0 ? (
           <Button
             variant="default"
             radius={9}
@@ -325,6 +341,31 @@ export default function TrainScheduleTrackPage() {
             Intercity Marshalling
           </Button>
         ) : null}
+        {(inTransit || arrived) && marshallingStops.length > 0 ? (
+          <Menu position="bottom-end" withinPortal>
+            <Menu.Target>
+              <Button
+                variant="default"
+                radius={9}
+                size="compact-sm"
+                leftSection={<FileText size={15} color={T.brand} />}
+                loading={intercityMarshalling.isPending}
+              >
+                Marshalling
+              </Button>
+            </Menu.Target>
+            <Menu.Dropdown>
+              {marshallingStops.map((stop) => (
+                <Menu.Item
+                  key={stop.stopIndex}
+                  onClick={() => void openIntercityMarshalling(stop.stopIndex)}
+                >
+                  {`Marshalling ${stop.stopIndex} — ${stop.yardLabel}`}
+                </Menu.Item>
+              ))}
+            </Menu.Dropdown>
+          </Menu>
+        ) : null}
       </Group>
 
       {/* ── Two-column work surface ── */}
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
index 94da4837e..26d9d7f88 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2DetailPage.tsx
@@ -257,13 +257,34 @@ export default function TrainScheduleV2DetailPage() {
   const switchGov = useMutation(api.trainScheduling.switchGovernmentBooking.mutationOptions());
   const dispatch = useMutation(api.trainScheduling.dispatchSchedule.mutationOptions());
   const downloadMarshalling = useMutation({
-    mutationFn: ({ id, direction, variant }: { id: string; direction?: string | null; variant?: "INTERCITY" }) =>
-      variant === "INTERCITY"
-        ? trainSchedulingService.downloadIntercityMarshallingDocument(id)
-        : direction === "EXPORT"
-          ? trainSchedulingService.downloadExportLoadListDocument(id)
-          : trainSchedulingService.downloadImportDjiboutiLoadListDocument(id),
+    mutationFn: ({
+      id,
+      direction,
+      variant,
+      stopIndex,
+    }: {
+      id: string;
+      direction?: string | null;
+      variant?: "INTERCITY";
+      stopIndex?: number;
+    }) =>
+      stopIndex != null
+        ? trainSchedulingService.downloadMarshallingDocumentAt(id, stopIndex)
+        : variant === "INTERCITY"
+          ? trainSchedulingService.downloadIntercityMarshallingDocument(id)
+          : direction === "EXPORT"
+            ? trainSchedulingService.downloadExportLoadListDocument(id)
+            : trainSchedulingService.downloadImportDjiboutiLoadListDocument(id),
   });
+  // Numbered marshalling docs (Marshalling 2, 3, 4…) — one per corridor stop
+  // that actually coupled/uncoupled something. Empty when nothing has yet.
+  const marshallingStopsQuery = useQuery(
+    api.trainScheduling.marshallingStops.queryOptions({
+      input: { id: scheduleId ?? "" },
+      enabled: Boolean(scheduleId) && ["DISPATCHED", "ARRIVED"].includes(schedule?.status ?? ""),
+    }),
+  );
+  const marshallingStops = marshallingStopsQuery.data ?? [];
 
   useEffect(() => {
     const operation = gatepassQuery.data;
@@ -506,6 +527,7 @@ export default function TrainScheduleV2DetailPage() {
     successDescription?: string;
     errorTitle?: string;
     variant?: "INTERCITY";
+    stopIndex?: number;
   }) => {
     const pdfWindow = window.open("", "_blank");
     try {
@@ -513,13 +535,16 @@ export default function TrainScheduleV2DetailPage() {
         id: scheduleId,
         direction: schedule.direction,
         variant: options?.variant,
+        stopIndex: options?.stopIndex,
       });
       const prefix =
-        options?.variant === "INTERCITY"
-          ? "intercity-marshalling"
-          : schedule.direction === "EXPORT"
-            ? "export-marshalling"
-            : "import-marshalling";
+        options?.stopIndex != null
+          ? `marshalling-${options.stopIndex}`
+          : options?.variant === "INTERCITY"
+            ? "intercity-marshalling"
+            : schedule.direction === "EXPORT"
+              ? "export-marshalling"
+              : "import-marshalling";
       const filename = `${prefix}-${schedule.trainNumber ?? scheduleId}.pdf`;
       const opened = openPdfBlob(blob, filename, pdfWindow);
       toast({
@@ -1108,7 +1133,7 @@ export default function TrainScheduleV2DetailPage() {
                     Marshalling PDF
                   </Menu.Item>
                 ) : null}
-                {["DISPATCHED", "ARRIVED"].includes(schedule.status) ? (
+                {["DISPATCHED", "ARRIVED"].includes(schedule.status) && marshallingStops.length === 0 ? (
                   <Menu.Item
                     leftSection={<FileText size={15} />}
                     disabled={downloadMarshalling.isPending}
@@ -1122,6 +1147,25 @@ export default function TrainScheduleV2DetailPage() {
                     Intercity Marshalling
                   </Menu.Item>
                 ) : null}
+                {/* One item per corridor stop that actually coupled/uncoupled
+                    something (Marshalling 2, 3, 4…) — replaces the single
+                    "current position" item once anything has happened. */}
+                {marshallingStops.map((stop) => (
+                  <Menu.Item
+                    key={stop.stopIndex}
+                    leftSection={<FileText size={15} />}
+                    disabled={downloadMarshalling.isPending}
+                    onClick={() =>
+                      void openMarshallingDocument({
+                        title: `Marshalling ${stop.stopIndex} ready`,
+                        successDescription: `${stop.yardLabel} — coupled/uncoupled wagons included.`,
+                        stopIndex: stop.stopIndex,
+                      })
+                    }
+                  >
+                    {`Marshalling ${stop.stopIndex} — ${stop.yardLabel}`}
+                  </Menu.Item>
+                ))}
                 {["DISPATCHED", "ARRIVED"].includes(schedule.status) ? (
                   <Menu.Item
                     component={Link}
@@ -1159,6 +1203,18 @@ export default function TrainScheduleV2DetailPage() {
         }
       />
 
+      {schedule.status === "CANCELLED" && schedule.cancellationReason ? (
+        <Alert
+          color="red"
+          variant="light"
+          radius="md"
+          icon={<AlertTriangle size={18} />}
+          title="This schedule was cancelled"
+        >
+          {schedule.cancellationReason}
+        </Alert>
+      ) : null}
+
       {/* Ops signage: Train No. / Voyage No. / Direction read at a glance from
           across the room, so these stay large rather than folding into the
           numeric KpiStrip below. */}
diff --git a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
index 8041ad3ad..f9857fa5b 100644
--- a/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/trainScheduling/TrainScheduleV2ListPage.tsx
@@ -17,6 +17,7 @@ import {
   Stack,
   Switch,
   Text,
+  Textarea,
   TextInput,
   ThemeIcon,
 } from "@mantine/core";
@@ -150,6 +151,9 @@ export default function TrainScheduleV2ListPage() {
   const [dispatchAt, setDispatchAt] = useState<Date | null>(null);
   // Cancelling is likewise irreversible — confirmed before the mutation fires.
   const [cancelTarget, setCancelTarget] = useState<TrainScheduleListItem | null>(null);
+  // Required: the reason is stored on the schedule and shown wherever the
+  // cancelled train appears, so staff downstream know why it died.
+  const [cancelReason, setCancelReason] = useState("");
   const [editDateSchedule, setEditDateSchedule] = useState<TrainScheduleListItem | null>(null);
   const [routeId, setRouteId] = useState("");
   const [scheduleDate, setScheduleDate] = useState("");
@@ -823,7 +827,10 @@ export default function TrainScheduleV2ListPage() {
           confirmed here rather than firing straight from the row menu. */}
       <Modal
         opened={cancelTarget != null}
-        onClose={() => setCancelTarget(null)}
+        onClose={() => {
+          setCancelTarget(null);
+          setCancelReason("");
+        }}
         title="Cancel this schedule?"
         centered
         radius="md"
@@ -842,23 +849,43 @@ export default function TrainScheduleV2ListPage() {
               another schedule.
             </Text>
           ) : null}
+          <Textarea
+            label="Reason for cancelling"
+            placeholder="e.g. locomotive failure, track closure, insufficient cargo"
+            value={cancelReason}
+            onChange={(e) => setCancelReason(e.currentTarget.value)}
+            autosize
+            minRows={2}
+            maxLength={500}
+            required
+            data-autofocus
+          />
           <Group justify="flex-end" gap="sm">
-            <Button variant="default" onClick={() => setCancelTarget(null)}>
+            <Button
+              variant="default"
+              onClick={() => {
+                setCancelTarget(null);
+                setCancelReason("");
+              }}
+            >
               Keep schedule
             </Button>
             <Button
               color="red"
               leftSection={<Ban size={16} />}
               loading={cancel.isPending}
+              disabled={!cancelReason.trim()}
               onClick={async () => {
-                if (!cancelTarget) return;
+                if (!cancelTarget || !cancelReason.trim()) return;
                 try {
                   await cancel.mutateAsync({
                     id: cancelTarget.id,
                     freightType: cancelTarget.freightType ?? "CONTAINER",
+                    reason: cancelReason.trim(),
                   });
                   toast({ title: "Schedule cancelled" });
                   setCancelTarget(null);
+                  setCancelReason("");
                   void schedulesQuery.refetch();
                 } catch (err) {
                   toast({
@@ -929,6 +956,11 @@ function TrainIdentityCell({ schedule }: { schedule: TrainScheduleListItem }) {
         </Text>
         <StatusPill status={schedule.status} />
       </Group>
+      {schedule.status === "CANCELLED" && schedule.cancellationReason ? (
+        <Text size="xs" c="red.7" lh={1.2} truncate title={schedule.cancellationReason}>
+          {schedule.cancellationReason}
+        </Text>
+      ) : null}
     </Stack>
   );
 }
@@ -1041,6 +1073,15 @@ function ScheduleCard({
           <MetricChip value={schedule.bookingsCount} label="bkg" />
         </Group>
 
+        {schedule.status === "CANCELLED" && schedule.cancellationReason ? (
+          <Text size="xs" c="red.7" lineClamp={2}>
+            <Text span fw={600}>
+              Cancelled:
+            </Text>{" "}
+            {schedule.cancellationReason}
+          </Text>
+        ) : null}
+
         <Group gap="xs" wrap="nowrap">
           <Button
             variant="light"
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/ContainerReturnsPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/ContainerReturnsPage.tsx
index 12539a136..c3896ca31 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/ContainerReturnsPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/ContainerReturnsPage.tsx
@@ -18,8 +18,10 @@ import {
   Textarea,
   Select,
   Checkbox,
+  Autocomplete,
+  Input,
 } from "@mantine/core";
-import { ChevronDown, ChevronRight, FileText, History } from "lucide-react";
+import { ChevronDown, ChevronRight, Download, FileText, History, Upload } from "lucide-react";
 import { DataTable, type ColumnDef } from "@edr/ui-common";
 
 import { PageContainer, PageHeader } from "@/components/page";
@@ -27,6 +29,9 @@ import ListControls from "@/components/common/ListControls";
 import RuleEngineListFooter from "@/components/ruleEngine/RuleEngineListFooter";
 import { extractDownloadErrorMessage } from "@/components/warehouses/options";
 import { openPdfBlob } from "@/components/warehouses/pdf";
+import BulkContainerReturnModal from "@/components/warehouses/BulkContainerReturnModal";
+import { downloadContainerReturnTemplate } from "@/components/warehouses/container-return-excel";
+import { useCompanyOptions } from "@/components/warehouses/useCompanyOptions";
 import { OverviewHorizontalBarChart } from "@/components/overview/OverviewHorizontalBarChart";
 import { OverviewStackedBarChart } from "@/components/overview/OverviewStackedBarChart";
 import { useListControls, toDayString } from "@/hooks/useListControls";
@@ -41,7 +46,7 @@ import type {
   EmptyContainerSize,
 } from "@/types/importOperations";
 import type { TrainScheduleListItem } from "@/types/trainScheduling";
-import { formatDateTime } from "@/lib/format";
+import { formatDateTime, localNowForInput } from "@/lib/format";
 
 type ReturnType = "all" | "edr" | "customer";
 
@@ -102,6 +107,7 @@ export default function ContainerReturnsPage() {
   const [filterType, setFilterType] = useState<ReturnType>("all");
   const [returnModalOpen, setReturnModalOpen] = useState(false);
   const [standaloneModalOpen, setStandaloneModalOpen] = useState(false);
+  const [bulkModalOpen, setBulkModalOpen] = useState(false);
   const [activeKey, setActiveKey] = useState<string | null>(null);
   const [historyRow, setHistoryRow] = useState<any | null>(null);
   const [allocateRow, setAllocateRow] = useState<EmptyContainerReturn | null>(null);
@@ -287,11 +293,14 @@ export default function ContainerReturnsPage() {
         bookingId: string;
         customerId: string | null;
         returnType: "EDR" | "CUSTOMER";
+        companyName?: string;
         containers: Array<{
           containerNumber: string;
           containerSize?: EmptyContainerSize;
           returnDate: string;
           warehouse: string;
+          yard?: string;
+          zone?: string;
           condition?: string;
           handoverNote?: string;
         }>;
@@ -306,7 +315,10 @@ export default function ContainerReturnsPage() {
             returnDate: new Date(container.returnDate).toISOString(),
             bookingId: truck.bookingId,
             customerId: truck.customerId ?? undefined,
+            companyName: truck.companyName,
             facility: container.warehouse,
+            yard: container.yard,
+            zone: container.zone,
             condition: container.condition,
             handoverNote: container.handoverNote,
             returnedBy: truck.returnType,
@@ -319,7 +331,9 @@ export default function ContainerReturnsPage() {
     onSuccess: () => {
       toast({ title: "Container returns recorded" });
       qc.invalidateQueries({ queryKey: ["container-returns", bookingIds] });
+      qc.invalidateQueries({ queryKey: ["empty-container-returns"] });
       setReturnModalOpen(false);
+      setStandaloneModalOpen(false);
       setActiveKey(null);
     },
     onError: (error: any) => {
@@ -372,9 +386,15 @@ export default function ContainerReturnsPage() {
       ),
     },
     {
-      id: "bookingRef",
-      header: "Booking Ref",
-      cell: ({ row }) => (row.original.bookingId ? "Associated" : "—"),
+      id: "company",
+      header: "Company",
+      // One identity column: who the box belongs to, and the booking it came
+      // back on. A standalone return has no booking, so only the name shows.
+      cell: ({ row }) => {
+        const { companyName, bookingReference } = row.original;
+        if (!companyName) return bookingReference || "—";
+        return bookingReference ? `${companyName} (${bookingReference})` : companyName;
+      },
     },
     {
       id: "returnedBy",
@@ -390,9 +410,8 @@ export default function ContainerReturnsPage() {
     },
     {
       id: "returnDate",
-      header: "Returned Date",
-      cell: ({ row }) =>
-        row.original.returnDate ? new Date(row.original.returnDate).toLocaleDateString() : "—",
+      header: "Returned Date & Time",
+      cell: ({ row }) => formatDateTime(row.original.returnDate),
     },
     {
       id: "facility",
@@ -510,9 +529,23 @@ export default function ContainerReturnsPage() {
             { label: "Customer Self-Haul", value: "customer" },
           ]}
         />
-        <Button onClick={() => setStandaloneModalOpen(true)}>
-          Record Return
-        </Button>
+        <Group gap="sm">
+          <Button
+            variant="subtle"
+            leftSection={<Download size={16} />}
+            onClick={() => downloadContainerReturnTemplate()}
+          >
+            Download Template
+          </Button>
+          <Button
+            variant="default"
+            leftSection={<Upload size={16} />}
+            onClick={() => setBulkModalOpen(true)}
+          >
+            Bulk Upload
+          </Button>
+          <Button onClick={() => setStandaloneModalOpen(true)}>Record Return</Button>
+        </Group>
       </Group>
 
       {returnedContainers.length > 0 && (
@@ -688,6 +721,12 @@ export default function ContainerReturnsPage() {
         loading={createReturnsMutation.isPending}
       />
 
+      <BulkContainerReturnModal
+        opened={bulkModalOpen}
+        onClose={() => setBulkModalOpen(false)}
+        onUploaded={() => qc.invalidateQueries({ queryKey: ["empty-container-returns"] })}
+      />
+
       <ExportTrainAllocationModal
         row={allocateRow}
         onClose={() => setAllocateRow(null)}
@@ -848,7 +887,7 @@ interface ContainerReturnModalProps {
 
 function ContainerReturnModal({ opened, onClose, group, onSubmit, loading }: ContainerReturnModalProps) {
   const [selectedContainers, setSelectedContainers] = useState<string[]>([]);
-  const [returnDate, setReturnDate] = useState<string>(new Date().toISOString().split("T")[0]);
+  const [returnDate, setReturnDate] = useState<string>(localNowForInput());
   const [warehouse, setWarehouse] = useState<string | null>(null);
   const [condition, setCondition] = useState<string>("");
   const [handoverNote, setHandoverNote] = useState<string>("");
@@ -940,13 +979,20 @@ function ContainerReturnModal({ opened, onClose, group, onSubmit, loading }: Con
             searchable
           />
 
-          <input
-            type="date"
-            value={returnDate}
-            onChange={(e) => setReturnDate(e.target.value)}
-            style={{ padding: "8px", borderRadius: "4px", border: "1px solid #ccc" }}
-            required
-          />
+          <Input.Wrapper label="Returned Date & Time" required>
+            <input
+              type="datetime-local"
+              value={returnDate}
+              onChange={(e) => setReturnDate(e.target.value)}
+              style={{
+                padding: "8px",
+                borderRadius: "4px",
+                border: "1px solid #ced4da",
+                width: "100%",
+              }}
+              required
+            />
+          </Input.Wrapper>
 
           <Textarea
             label="Condition"
@@ -991,9 +1037,10 @@ interface StandaloneReturnModalProps {
 
 function StandaloneReturnModal({ opened, onClose, onSubmit, loading }: StandaloneReturnModalProps) {
   const [containerNumber, setContainerNumber] = useState<string>("");
+  const [company, setCompany] = useState<string>("");
   const [containerSize, setContainerSize] = useState<EmptyContainerSize | null>(null);
   const [returnedBy, setReturnedBy] = useState<"EDR" | "CUSTOMER" | null>(null);
-  const [returnDate, setReturnDate] = useState<string>(new Date().toISOString().split("T")[0]);
+  const [returnDate, setReturnDate] = useState<string>(localNowForInput());
   const [warehouse, setWarehouse] = useState<string | null>(null);
   const [yardId, setYardId] = useState<string | null>(null);
   const [zoneId, setZoneId] = useState<string | null>(null);
@@ -1009,6 +1056,7 @@ function StandaloneReturnModal({ opened, onClose, onSubmit, loading }: Standalon
 
   const warehouses = (warehousesResponse as any)?.data ?? warehousesResponse ?? [];
 
+  const companies = useCompanyOptions();
   const { data: yards } = useWarehouseYards(warehouse ?? undefined);
   const { data: zones } = useWarehouseZones(yardId ?? undefined);
 
@@ -1047,7 +1095,8 @@ function StandaloneReturnModal({ opened, onClose, onSubmit, loading }: Standalon
       trucks: [
         {
           bookingId: null,
-          customerId: null,
+          customerId: company ? (companies.resolveId(company) ?? null) : null,
+          companyName: company || undefined,
           returnType: returnedBy,
           containers: [
             {
@@ -1066,9 +1115,10 @@ function StandaloneReturnModal({ opened, onClose, onSubmit, loading }: Standalon
     });
 
     setContainerNumber("");
+    setCompany("");
     setContainerSize(null);
     setReturnedBy(null);
-    setReturnDate(new Date().toISOString().split("T")[0]);
+    setReturnDate(localNowForInput());
     setWarehouse(null);
     setYardId(null);
     setZoneId(null);
@@ -1092,6 +1142,16 @@ function StandaloneReturnModal({ opened, onClose, onSubmit, loading }: Standalon
           required
         />
 
+        <Autocomplete
+          label="Company"
+          description="Pick a registered customer, or type a company that is not on the system yet"
+          placeholder={companies.loading ? "Loading companies…" : "Search or type a company"}
+          data={companies.names}
+          value={company}
+          onChange={setCompany}
+          limit={20}
+        />
+
         <Select
           label="Returned By"
           placeholder="Select truck type"
@@ -1145,13 +1205,20 @@ function StandaloneReturnModal({ opened, onClose, onSubmit, loading }: Standalon
           searchable
         />
 
-        <input
-          type="date"
-          value={returnDate}
-          onChange={(e) => setReturnDate(e.target.value)}
-          style={{ padding: "8px", borderRadius: "4px", border: "1px solid #ccc" }}
-          required
-        />
+        <Input.Wrapper label="Returned Date & Time" required>
+          <input
+            type="datetime-local"
+            value={returnDate}
+            onChange={(e) => setReturnDate(e.target.value)}
+            style={{
+              padding: "8px",
+              borderRadius: "4px",
+              border: "1px solid #ced4da",
+              width: "100%",
+            }}
+            required
+          />
+        </Input.Wrapper>
 
         <Textarea
           label="Condition"
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/RegisterFullContainersPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/RegisterFullContainersPage.tsx
new file mode 100644
index 000000000..2a63bfe7e
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/RegisterFullContainersPage.tsx
@@ -0,0 +1,442 @@
+import { useEffect, useMemo, useState } from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  Alert,
+  Autocomplete,
+  Badge,
+  Button,
+  Card,
+  Group,
+  Input,
+  List,
+  NumberInput,
+  ScrollArea,
+  SegmentedControl,
+  Select,
+  Stack,
+  Table,
+  Text,
+  TextInput,
+  Textarea,
+} from "@mantine/core";
+import { Download, Upload } from "lucide-react";
+
+import { PageContainer, PageHeader } from "@/components/page";
+import { useCompanyOptions } from "@/components/warehouses/useCompanyOptions";
+import {
+  downloadFullContainerTemplate,
+  parseFullContainerExcel,
+  type ParsedFullContainerRow,
+} from "@/components/warehouses/full-container-excel";
+import { useToast } from "@/hooks/use-toast";
+import { useWarehouseYards, useWarehouseZones } from "@/hooks/useWarehouses";
+import { containerTypesService } from "@/services/container-types.service";
+import { warehouseService } from "@/services/warehouse.service";
+import type { RegisterBacklogContainerPayload } from "@/types/warehouse";
+
+/** `YYYY-MM-DD` for today — the latest arrival a backlog box can claim. */
+function todayForInput(): string {
+  const d = new Date();
+  d.setMinutes(d.getMinutes() - d.getTimezoneOffset());
+  return d.toISOString().slice(0, 10);
+}
+
+/**
+ * Loaded containers that have been sitting in a yard since before the system
+ * knew about them. Registering one records its true arrival date without
+ * billing storage for the history — the server flags the row so the fee engine
+ * skips it entirely.
+ */
+export default function RegisterFullContainersPage() {
+  const { toast } = useToast();
+  const qc = useQueryClient();
+  const companies = useCompanyOptions();
+  const [mode, setMode] = useState<"single" | "bulk">("single");
+
+  // Location + owner, shared by both modes. In bulk they are the defaults that
+  // fill any blank cell in the sheet.
+  const [company, setCompany] = useState("");
+  const [warehouseId, setWarehouseId] = useState<string | null>(null);
+  const [yardId, setYardId] = useState<string | null>(null);
+  const [zoneId, setZoneId] = useState<string | null>(null);
+  const [arrivedAt, setArrivedAt] = useState(todayForInput());
+  const [containerTypeId, setContainerTypeId] = useState<string | null>(null);
+
+  // Single-container fields.
+  const [containerNumber, setContainerNumber] = useState("");
+  const [sealNumber, setSealNumber] = useState("");
+  const [weight, setWeight] = useState<number | string>("");
+  const [notes, setNotes] = useState("");
+
+  // Bulk fields.
+  const [file, setFile] = useState<File | null>(null);
+  const [rows, setRows] = useState<ParsedFullContainerRow[]>([]);
+  const [parseErrors, setParseErrors] = useState<string[]>([]);
+
+  const { data: warehousesResponse } = useQuery({
+    queryKey: ["warehouses-list"],
+    queryFn: () => warehouseService.list({}),
+  });
+  const warehouses = ((warehousesResponse as any)?.data ?? warehousesResponse ?? []) as any[];
+  const { data: yards } = useWarehouseYards(warehouseId ?? undefined);
+  const { data: zones } = useWarehouseZones(yardId ?? undefined);
+
+  const { data: containerTypes = [] } = useQuery({
+    queryKey: ["container-types-active"],
+    queryFn: () => containerTypesService.getContainerTypes(),
+    staleTime: 5 * 60 * 1000,
+  });
+
+  useEffect(() => {
+    setYardId(null);
+    setZoneId(null);
+  }, [warehouseId]);
+  useEffect(() => setZoneId(null), [yardId]);
+
+  const warehouseOptions = Array.isArray(warehouses)
+    ? warehouses.map((wh) => ({ value: wh.id, label: wh.code ? `${wh.name} (${wh.code})` : wh.name }))
+    : [];
+  const yardOptions = (yards ?? [])
+    .filter((y) => y.status === "ACTIVE")
+    .map((y) => ({ value: y.id, label: `${y.name} (${y.code})` }));
+  const zoneOptions = (zones ?? [])
+    .filter((z) => z.status === "ACTIVE")
+    .map((z) => ({ value: z.id, label: `${z.name} (${z.code})` }));
+  const containerTypeOptions = (containerTypes as any[]).map((ct) => ({
+    value: ct.id,
+    label: ct.label ? `${ct.label} (${ct.code})` : ct.code,
+  }));
+
+  const locationReady = Boolean(warehouseId && yardId && zoneId);
+
+  const basePayload = useMemo(
+    () => ({
+      warehouseId: warehouseId ?? "",
+      yardId: yardId ?? "",
+      zoneId: zoneId ?? "",
+      companyId: company ? companies.resolveId(company) : undefined,
+      companyName: company || undefined,
+    }),
+    [warehouseId, yardId, zoneId, company, companies],
+  );
+
+  const onSaved = (count: number) => {
+    toast({ title: `${count} container${count === 1 ? "" : "s"} registered` });
+    qc.invalidateQueries({ queryKey: ["warehouse-inventory"] });
+  };
+
+  const singleMutation = useMutation({
+    mutationFn: () =>
+      warehouseService.registerBacklogContainer({
+        ...basePayload,
+        containerNumber: containerNumber.trim().toUpperCase(),
+        containerTypeId: containerTypeId ?? "",
+        arrivedAt: new Date(arrivedAt).toISOString(),
+        sealNumber: sealNumber.trim() || undefined,
+        weight: weight === "" ? undefined : Number(weight),
+        notes: notes.trim() || undefined,
+      }),
+    onSuccess: () => {
+      onSaved(1);
+      setContainerNumber("");
+      setSealNumber("");
+      setWeight("");
+      setNotes("");
+    },
+    onError: (error: any) =>
+      toast({
+        variant: "destructive",
+        title: "Could not register container",
+        description: error?.response?.data?.message || error?.message,
+      }),
+  });
+
+  // Row cell wins; the fields above the file fill the blanks.
+  const toPayload = (row: ParsedFullContainerRow): RegisterBacklogContainerPayload => ({
+    ...basePayload,
+    companyName: row.companyName || basePayload.companyName,
+    companyId: row.companyName ? companies.resolveId(row.companyName) : basePayload.companyId,
+    containerNumber: row.containerNumber,
+    containerTypeId: containerTypeId ?? "",
+    arrivedAt: row.arrivedAt ?? new Date(arrivedAt).toISOString(),
+    sealNumber: row.sealNumber || undefined,
+    weight: row.weight === "" ? undefined : Number(row.weight),
+    notes: row.notes || undefined,
+  });
+
+  const bulkMutation = useMutation({
+    mutationFn: () => warehouseService.registerBacklogContainersBulk(rows.map(toPayload)),
+    onSuccess: (response) => {
+      onSaved(response.data?.length ?? rows.length);
+      setFile(null);
+      setRows([]);
+      setParseErrors([]);
+    },
+    onError: (error: any) =>
+      toast({
+        variant: "destructive",
+        title: "Bulk registration failed",
+        description: error?.response?.data?.message || error?.message,
+      }),
+  });
+
+  const handleFile = async (next: File | null) => {
+    setFile(next);
+    setRows([]);
+    setParseErrors([]);
+    if (!next) return;
+    const result = await parseFullContainerExcel(next);
+    setRows(result.rows);
+    setParseErrors(result.errors);
+  };
+
+  const singleReady =
+    locationReady && Boolean(containerTypeId) && containerNumber.trim().length > 0 && Boolean(arrivedAt);
+  const bulkReady = locationReady && Boolean(containerTypeId) && rows.length > 0;
+
+  return (
+    <PageContainer>
+      <PageHeader
+        title="Register Full Containers"
+        subtitle="Loaded containers already in the yard but not yet on the system"
+      />
+
+      <Group mb="lg" justify="space-between">
+        <SegmentedControl
+          value={mode}
+          onChange={(v) => setMode(v as "single" | "bulk")}
+          data={[
+            { label: "Single Container", value: "single" },
+            { label: "Bulk Upload", value: "bulk" },
+          ]}
+        />
+        <Button
+          variant="subtle"
+          leftSection={<Download size={16} />}
+          onClick={() => downloadFullContainerTemplate()}
+        >
+          Download Template
+        </Button>
+      </Group>
+
+      <Alert color="blue" mb="lg" title="Backlog registrations are not billed">
+        The arrival date you enter is kept as the real record of how long the box has been here,
+        but no storage or demurrage accrues against it.
+      </Alert>
+
+      <Card withBorder radius="lg" p="md">
+        <Stack gap="md">
+          <Group grow align="flex-start">
+            <Autocomplete
+              label="Company"
+              description="Pick a registered customer, or type a company that is not on the system yet"
+              placeholder={companies.loading ? "Loading companies…" : "Search or type a company"}
+              data={companies.names}
+              value={company}
+              onChange={setCompany}
+              limit={20}
+            />
+            <Select
+              label="Container Type"
+              placeholder="Select container type"
+              value={containerTypeId}
+              onChange={setContainerTypeId}
+              data={containerTypeOptions}
+              searchable
+              required
+            />
+          </Group>
+
+          <Group grow align="flex-start">
+            <Select
+              label="Warehouse"
+              placeholder="Select warehouse"
+              value={warehouseId}
+              onChange={setWarehouseId}
+              data={warehouseOptions}
+              searchable
+              required
+            />
+            <Select
+              label="Yard"
+              placeholder={warehouseId ? "Select yard" : "Select warehouse first"}
+              value={yardId}
+              onChange={setYardId}
+              data={yardOptions}
+              disabled={!warehouseId}
+              searchable
+              required
+            />
+            <Select
+              label="Zone"
+              placeholder={yardId ? "Select zone" : "Select yard first"}
+              value={zoneId}
+              onChange={setZoneId}
+              data={zoneOptions}
+              disabled={!yardId}
+              searchable
+              required
+            />
+          </Group>
+
+          <Input.Wrapper
+            label="Arrival Date"
+            description={
+              mode === "bulk"
+                ? "Used for any row whose sheet cell is blank"
+                : "When the container actually arrived in the yard"
+            }
+            required
+          >
+            <input
+              type="date"
+              value={arrivedAt}
+              max={todayForInput()}
+              onChange={(e) => setArrivedAt(e.target.value)}
+              style={{
+                padding: "8px",
+                borderRadius: "4px",
+                border: "1px solid #ced4da",
+                width: "100%",
+              }}
+            />
+          </Input.Wrapper>
+
+          {mode === "single" ? (
+            <>
+              <Group grow align="flex-start">
+                <TextInput
+                  label="Container Number"
+                  placeholder="e.g., TEMU1234567"
+                  value={containerNumber}
+                  onChange={(e) => setContainerNumber(e.currentTarget.value)}
+                  required
+                />
+                <TextInput
+                  label="Seal Number"
+                  placeholder="Optional"
+                  value={sealNumber}
+                  onChange={(e) => setSealNumber(e.currentTarget.value)}
+                />
+                <NumberInput
+                  label="Weight (Tons)"
+                  placeholder="Optional"
+                  value={weight}
+                  onChange={setWeight}
+                  min={0}
+                  decimalScale={3}
+                />
+              </Group>
+
+              <Textarea
+                label="Notes"
+                placeholder="Where it came from, condition, anything worth recording"
+                value={notes}
+                onChange={(e) => setNotes(e.currentTarget.value)}
+                rows={3}
+              />
+
+              <Group justify="flex-end">
+                <Button
+                  onClick={() => singleMutation.mutate()}
+                  disabled={!singleReady}
+                  loading={singleMutation.isPending}
+                >
+                  Register Container
+                </Button>
+              </Group>
+            </>
+          ) : (
+            <>
+              <Input.Wrapper label="Excel file" description="One row per container">
+                <input
+                  type="file"
+                  accept=".xlsx,.xls"
+                  onChange={(e) => void handleFile(e.target.files?.[0] ?? null)}
+                  style={{ display: "block", padding: "8px 0" }}
+                />
+              </Input.Wrapper>
+
+              {parseErrors.length > 0 && (
+                <Alert color="red" title={`${parseErrors.length} problem(s) — nothing was registered`}>
+                  <ScrollArea.Autosize mah={200}>
+                    <List size="sm">
+                      {parseErrors.map((err) => (
+                        <List.Item key={err}>{err}</List.Item>
+                      ))}
+                    </List>
+                  </ScrollArea.Autosize>
+                </Alert>
+              )}
+
+              {rows.length > 0 && (
+                <Stack gap="xs">
+                  <Group gap="xs">
+                    <Text fw={600} size="sm">
+                      Preview
+                    </Text>
+                    <Badge size="sm">{rows.length} containers</Badge>
+                    {file && (
+                      <Text size="xs" c="dimmed">
+                        {file.name}
+                      </Text>
+                    )}
+                  </Group>
+                  <ScrollArea.Autosize mah={320}>
+                    <Table striped highlightOnHover withTableBorder>
+                      <Table.Thead>
+                        <Table.Tr>
+                          <Table.Th>Container</Table.Th>
+                          <Table.Th>Company</Table.Th>
+                          <Table.Th>Arrived</Table.Th>
+                          <Table.Th>Seal</Table.Th>
+                          <Table.Th>Weight</Table.Th>
+                        </Table.Tr>
+                      </Table.Thead>
+                      <Table.Tbody>
+                        {rows.map((row) => {
+                          const payload = toPayload(row);
+                          return (
+                            <Table.Tr key={row.containerNumber}>
+                              <Table.Td>{payload.containerNumber}</Table.Td>
+                              <Table.Td>
+                                <Group gap={4} wrap="nowrap">
+                                  <Text size="sm">{payload.companyName || "—"}</Text>
+                                  {payload.companyName && !payload.companyId && (
+                                    <Badge size="xs" color="orange" variant="light">
+                                      New
+                                    </Badge>
+                                  )}
+                                </Group>
+                              </Table.Td>
+                              <Table.Td>
+                                {new Date(payload.arrivedAt).toLocaleDateString()}
+                              </Table.Td>
+                              <Table.Td>{payload.sealNumber ?? "—"}</Table.Td>
+                              <Table.Td>{payload.weight ?? "—"}</Table.Td>
+                            </Table.Tr>
+                          );
+                        })}
+                      </Table.Tbody>
+                    </Table>
+                  </ScrollArea.Autosize>
+                </Stack>
+              )}
+
+              <Group justify="flex-end">
+                <Button
+                  leftSection={<Upload size={16} />}
+                  onClick={() => bulkMutation.mutate()}
+                  disabled={!bulkReady}
+                  loading={bulkMutation.isPending}
+                >
+                  Register {rows.length > 0 ? `${rows.length} containers` : ""}
+                </Button>
+              </Group>
+            </>
+          )}
+        </Stack>
+      </Card>
+    </PageContainer>
+  );
+}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx
index e3680fe73..2ea0b64d2 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseDetailPage.tsx
@@ -1,4 +1,4 @@
-import { useMemo, useState } from 'react';
+import { useCallback, useMemo, useState } from 'react';
 import { useNavigate, useParams } from 'react-router-dom';
 import {
   ActionIcon,
@@ -12,8 +12,8 @@ import {
   Tabs,
   Text,
 } from '@mantine/core';
-import { ArrowLeft, Boxes, LayoutGrid, Package, Pencil, Plus } from 'lucide-react';
-import { useQuery } from '@tanstack/react-query';
+import { ArrowLeft, Boxes, Layers, LayoutGrid, Package, Pencil, Plus, Trash2 } from 'lucide-react';
+import { useMutation, useQuery } from '@tanstack/react-query';
 import { DataTable, type ColumnDef } from '@edr/ui-common';
 
 import { KpiStrip, PageContainer, PageHeader } from '@/components/page';
@@ -23,16 +23,27 @@ import {
   InventoryWorkbench,
   WarehouseStatusBadge,
   WarehouseTypeBadge,
+  ZoneContentsModal,
+  type ZoneRef,
+  ZoneLayoutModal,
   ZoneOccupancyHeatmap,
   formatCapacity,
   humanizeEnum,
 } from '@/components/warehouses';
+import { useAuth } from '@/auth/useAuth';
+import { useToast } from '@/hooks/use-toast';
+import { extractErrorMessage } from '@/components/warehouses/options';
+import { FREIGHT_PERMS, hasPermission } from '@/lib/permissions';
 import { api } from '@/services/api';
 import type { WarehouseYard, WarehouseZone } from '@/types/warehouse';
 
 export default function WarehouseDetailPage() {
   const { id } = useParams<{ id: string }>();
   const navigate = useNavigate();
+  const { toast } = useToast();
+  const { user } = useAuth();
+  const canDeleteYard = hasPermission(user, FREIGHT_PERMS.warehouseYards.delete);
+  const canDeleteZone = hasPermission(user, FREIGHT_PERMS.warehouseZones.delete);
 
   const { data: warehouse, isLoading } = useQuery(
     api.warehouses.getById.queryOptions({
@@ -52,6 +63,8 @@ export default function WarehouseDetailPage() {
   const [zoneModalOpen, setZoneModalOpen] = useState(false);
   const [editingZone, setEditingZone] = useState<WarehouseZone | null>(null);
   const [selectedYardId, setSelectedYardId] = useState<string | null>(null);
+  const [contentsZone, setContentsZone] = useState<ZoneRef | null>(null);
+  const [layoutZone, setLayoutZone] = useState<ZoneRef | null>(null);
 
   const zonesQuery = useQuery(
     api.warehouses.listZones.queryOptions({
@@ -72,6 +85,44 @@ export default function WarehouseDetailPage() {
     [yards],
   );
 
+  const deleteYard = useMutation(api.warehouses.deleteYard.mutationOptions());
+  const deleteZone = useMutation(api.warehouses.deleteZone.mutationOptions());
+
+  // The API refuses a yard that still has zones (and a zone that still holds
+  // inventory) with a 409 — surface that message rather than a bare failure.
+  const removeYard = useCallback(
+    (yard: WarehouseYard) => {
+      if (!window.confirm(`Delete yard ${yard.code}? Its zones must be removed first.`)) return;
+      deleteYard.mutate(
+        { id: yard.id },
+        {
+          onSuccess: () => toast({ title: `Yard ${yard.code} deleted` }),
+          onError: (error) =>
+            toast({ variant: 'destructive', title: 'Delete failed', description: extractErrorMessage(error) }),
+        },
+      );
+    },
+    [deleteYard, toast],
+  );
+
+  const removeZone = useCallback(
+    (zone: WarehouseZone) => {
+      if (!window.confirm(`Delete zone ${zone.code}? It must be empty first.`)) return;
+      deleteZone.mutate(
+        { id: zone.id },
+        {
+          onSuccess: () => {
+            toast({ title: `Zone ${zone.code} deleted` });
+            void zonesQuery.refetch();
+          },
+          onError: (error) =>
+            toast({ variant: 'destructive', title: 'Delete failed', description: extractErrorMessage(error) }),
+        },
+      );
+    },
+    [deleteZone, toast, zonesQuery],
+  );
+
   const yardColumns = useMemo<ColumnDef<WarehouseYard>[]>(
     () => [
       { id: 'name', header: 'Name', cell: ({ row }) => row.original.name },
@@ -98,20 +149,33 @@ export default function WarehouseDetailPage() {
         header: 'Actions',
         meta: { headerClassName: 'text-right', cellClassName: 'text-right' },
         cell: ({ row }) => (
-          <ActionIcon
-            variant="subtle"
-            color="gray"
-            onClick={() => {
-              setEditingYard(row.original);
-              setYardModalOpen(true);
-            }}
-          >
-            <Pencil size={16} />
-          </ActionIcon>
+          <Group gap={4} justify="flex-end" wrap="nowrap">
+            <ActionIcon
+              variant="subtle"
+              color="gray"
+              title="Edit"
+              onClick={() => {
+                setEditingYard(row.original);
+                setYardModalOpen(true);
+              }}
+            >
+              <Pencil size={16} />
+            </ActionIcon>
+            {canDeleteYard ? (
+              <ActionIcon
+                variant="subtle"
+                color="red"
+                title="Delete"
+                onClick={() => removeYard(row.original)}
+              >
+                <Trash2 size={16} />
+              </ActionIcon>
+            ) : null}
+          </Group>
         ),
       },
     ],
-    [],
+    [canDeleteYard, removeYard],
   );
 
   const zoneColumns = useMemo<ColumnDef<WarehouseZone>[]>(
@@ -140,20 +204,41 @@ export default function WarehouseDetailPage() {
         header: 'Actions',
         meta: { headerClassName: 'text-right', cellClassName: 'text-right' },
         cell: ({ row }) => (
-          <ActionIcon
-            variant="subtle"
-            color="gray"
-            onClick={() => {
-              setEditingZone(row.original);
-              setZoneModalOpen(true);
-            }}
-          >
-            <Pencil size={16} />
-          </ActionIcon>
+          <Group gap={4} justify="flex-end" wrap="nowrap" onClick={(e) => e.stopPropagation()}>
+            <ActionIcon
+              variant="subtle"
+              color="gray"
+              title="Stack layout"
+              onClick={() => setLayoutZone(row.original)}
+            >
+              <Layers size={16} />
+            </ActionIcon>
+            <ActionIcon
+              variant="subtle"
+              color="gray"
+              title="Edit"
+              onClick={() => {
+                setEditingZone(row.original);
+                setZoneModalOpen(true);
+              }}
+            >
+              <Pencil size={16} />
+            </ActionIcon>
+            {canDeleteZone ? (
+              <ActionIcon
+                variant="subtle"
+                color="red"
+                title="Delete"
+                onClick={() => removeZone(row.original)}
+              >
+                <Trash2 size={16} />
+              </ActionIcon>
+            ) : null}
+          </Group>
         ),
       },
     ],
-    [],
+    [canDeleteZone, removeZone],
   );
 
   if (isLoading) {
@@ -299,7 +384,10 @@ export default function WarehouseDetailPage() {
                 </Button>
               </Group>
 
-              <ZoneOccupancyHeatmap yardId={selectedYardId ?? undefined} />
+              <ZoneOccupancyHeatmap
+                yardId={selectedYardId ?? undefined}
+                onZoneClick={(zone) => setContentsZone(zone)}
+              />
 
               {!selectedYardId ? (
                 <Text c="dimmed" ta="center" py="lg">
@@ -309,6 +397,7 @@ export default function WarehouseDetailPage() {
                 <DataTable
                   columns={zoneColumns}
                   data={zonesQuery.data ?? []}
+                  onRowClick={(zone) => setContentsZone(zone)}
                   status={
                     zonesQuery.isLoading ? 'loading' : zonesQuery.isError ? 'error' : 'success'
                   }
@@ -346,6 +435,18 @@ export default function WarehouseDetailPage() {
           yard={editingYard}
         />
       )}
+      <ZoneLayoutModal
+        opened={Boolean(layoutZone)}
+        onClose={() => setLayoutZone(null)}
+        zone={layoutZone}
+      />
+
+      <ZoneContentsModal
+        opened={Boolean(contentsZone)}
+        onClose={() => setContentsZone(null)}
+        zone={contentsZone}
+      />
+
       {selectedYardId && (
         <CreateZoneModal
           opened={zoneModalOpen}
diff --git a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseListPage.tsx b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseListPage.tsx
index 8b3600026..31512d4dc 100644
--- a/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseListPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/warehouses/WarehouseListPage.tsx
@@ -4,6 +4,7 @@ import { Button, Card, Center, Loader, Stack, Text } from '@mantine/core';
 import { useDebouncedValue } from '@mantine/hooks';
 import { Plus } from 'lucide-react';
 
+import { useAuth } from '@/auth/useAuth';
 import { PageContainer, PageHeader } from '@/components/page';
 import {
   CreateWarehouseModal,
@@ -17,11 +18,18 @@ import ListControls from '@/components/common/ListControls';
 // despite the ruleEngine path.
 import RuleEngineListFooter from '@/components/ruleEngine/RuleEngineListFooter';
 import { useListControls } from '@/hooks/useListControls';
-import { useWarehouses } from '@/hooks/useWarehouses';
+import { useToast } from '@/hooks/use-toast';
+import { useDeleteWarehouse, useWarehouses } from '@/hooks/useWarehouses';
+import { extractErrorMessage } from '@/components/warehouses/options';
+import { FREIGHT_PERMS, hasPermission } from '@/lib/permissions';
 import type { Warehouse, WarehouseFilter } from '@/types/warehouse';
 
 export default function WarehouseListPage() {
   const navigate = useNavigate();
+  const { toast } = useToast();
+  const { user } = useAuth();
+  const remove = useDeleteWarehouse();
+  const canDelete = hasPermission(user, FREIGHT_PERMS.warehouses.delete);
   const [filter, setFilter] = useState<WarehouseFilter>({});
   const [view, setView] = useState<WarehouseView>('table');
   const [modalOpen, setModalOpen] = useState(false);
@@ -50,6 +58,15 @@ export default function WarehouseListPage() {
     setModalOpen(true);
   };
   const openDetail = (warehouse: Warehouse) => navigate(`/dashboard/warehouses/${warehouse.id}`);
+  const handleDelete = (warehouse: Warehouse) => {
+    if (!window.confirm(`Delete warehouse ${warehouse.code}? Yards must be removed first.`)) return;
+    remove.mutate(warehouse.id, {
+      onSuccess: () => toast({ title: `Warehouse ${warehouse.code} deleted` }),
+      onError: (error) =>
+        toast({ variant: 'destructive', title: 'Delete failed', description: extractErrorMessage(error) }),
+    });
+  };
+  const onDelete = canDelete ? handleDelete : undefined;
 
   return (
     <PageContainer>
@@ -91,9 +108,19 @@ export default function WarehouseListPage() {
           ) : (
             <>
               {view === 'table' ? (
-                <WarehouseTable warehouses={controls.pagedRows} onView={openDetail} onEdit={openEdit} />
+                <WarehouseTable
+                  warehouses={controls.pagedRows}
+                  onView={openDetail}
+                  onEdit={openEdit}
+                  onDelete={onDelete}
+                />
               ) : (
-                <WarehouseCardView warehouses={controls.pagedRows} onView={openDetail} onEdit={openEdit} />
+                <WarehouseCardView
+                  warehouses={controls.pagedRows}
+                  onView={openDetail}
+                  onEdit={openEdit}
+                  onDelete={onDelete}
+                />
               )}
               <RuleEngineListFooter
                 pagination={controls.pagination}
diff --git a/apps/edr-freight-web/backoffice/src/services/api.ts b/apps/edr-freight-web/backoffice/src/services/api.ts
index d8c07f5c2..855b3805a 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -85,6 +85,7 @@ import type {
   UpdateCheckpointPayload,
   DispatchSchedulePayload,
   StaffBookingWindow,
+  MarshallingStop,
   ScheduleMergePreview,
   TrainScheduleDetail,
   TrainScheduleFilters,
@@ -152,6 +153,15 @@ import type {
   WarehouseLoading,
   WarehouseYard,
   WarehouseZone,
+  ZoneContentItem,
+  ZoneLayout,
+  ZoneSlotSummary,
+  WarehouseZoneStack,
+  WarehouseZoneSlot,
+  SaveStackPayload,
+  AvailableSlot,
+  ContainerAccessibility,
+  FindSlotPayload,
 } from "@/types/warehouse";
 import { endpoint } from "@/utils/endpoint";
 import {
@@ -595,6 +605,13 @@ export const api = {
       ({ id }) => QUERY_KEYS.TRAIN_SCHEDULING.track(id),
     ),
 
+    marshallingStops: endpoint<{ id: string }, MarshallingStop[]>(
+      "train-scheduling",
+      "marshalling-stops",
+      ({ id }) => trainSchedulingService.getMarshallingStops(id),
+      ({ id }) => QUERY_KEYS.TRAIN_SCHEDULING.marshallingStops(id),
+    ),
+
     unassignedBookings: endpoint<
       { scheduleId: string },
       UnassignedBookingsResponse
@@ -1044,13 +1061,17 @@ export const api = {
     ),
 
     cancelSchedule: endpoint<
-      { id: string; freightType?: FreightType },
+      { id: string; freightType?: FreightType; reason: string },
       TrainScheduleDetail
     >(
       "train-scheduling",
       "cancel-schedule",
-      ({ id, freightType }) =>
-        trainSchedulingService.cancelSchedule(id, freightType ?? "CONTAINER"),
+      ({ id, freightType, reason }) =>
+        trainSchedulingService.cancelSchedule(
+          id,
+          freightType ?? "CONTAINER",
+          reason,
+        ),
       undefined,
       () => TRAIN_SCHEDULING_INVALIDATIONS,
     ),
@@ -1199,6 +1220,14 @@ export const api = {
       () => [["warehouses"], ["warehouse-yards"]],
     ),
 
+    deleteYard: endpoint<{ id: string }, unknown>(
+      "warehouses",
+      "deleteYard",
+      ({ id }) => warehouseService.removeYard(id).then((r) => r.data),
+      undefined,
+      () => [["warehouses"], ["warehouse-yards"]],
+    ),
+
     // ── Zones ──────────────────────────────────────────────────────────────
     listZones: endpoint<{ yardId: string }, WarehouseZone[]>(
       "warehouses",
@@ -1231,6 +1260,100 @@ export const api = {
       () => [["warehouse-yards"]],
     ),
 
+    zoneContents: endpoint<{ zoneId: string }, ZoneContentItem[]>(
+      "warehouse-zones",
+      "contents",
+      ({ zoneId }) => warehouseService.zoneContents(zoneId).then((r) => r.data),
+      ({ zoneId }) => ["warehouse-zones", zoneId, "contents"],
+    ),
+
+    zoneLayout: endpoint<{ zoneId: string }, ZoneLayout>(
+      "warehouse-zones",
+      "layout",
+      ({ zoneId }) => warehouseService.zoneLayout(zoneId).then((r) => r.data),
+      ({ zoneId }) => ["warehouse-zones", zoneId, "layout"],
+    ),
+
+    zoneSlotSummary: endpoint<{ zoneId: string }, ZoneSlotSummary>(
+      "warehouse-zones",
+      "slot-summary",
+      ({ zoneId }) => warehouseService.zoneSlotSummary(zoneId).then((r) => r.data),
+      ({ zoneId }) => ["warehouse-zones", zoneId, "slot-summary"],
+    ),
+
+    // ── Ground stacks and slots ────────────────────────────────────────────
+    listStacks: endpoint<{ zoneId: string }, WarehouseZoneStack[]>(
+      "warehouse-zone-stacks",
+      "list",
+      ({ zoneId }) => warehouseService.listStacks(zoneId).then((r) => r.data),
+      ({ zoneId }) => ["warehouse-zone-stacks", zoneId],
+    ),
+
+    createStack: endpoint<
+      { zoneId: string; payload: SaveStackPayload },
+      WarehouseZoneStack
+    >(
+      "warehouse-zone-stacks",
+      "create",
+      ({ zoneId, payload }) =>
+        warehouseService.createStack(zoneId, payload).then((r) => r.data),
+      undefined,
+      ({ zoneId }) => [
+        ["warehouse-zone-stacks", zoneId],
+        ["warehouse-zones", zoneId, "layout"],
+        ["warehouse-zones", zoneId, "slot-summary"],
+      ],
+    ),
+
+    updateStack: endpoint<
+      { id: string; zoneId: string; payload: Partial<SaveStackPayload> },
+      WarehouseZoneStack
+    >(
+      "warehouse-zone-stacks",
+      "update",
+      ({ id, payload }) => warehouseService.updateStack(id, payload).then((r) => r.data),
+      undefined,
+      ({ zoneId }) => [
+        ["warehouse-zone-stacks", zoneId],
+        ["warehouse-zones", zoneId, "layout"],
+        ["warehouse-zones", zoneId, "slot-summary"],
+      ],
+    ),
+
+    deleteStack: endpoint<{ id: string; zoneId: string }, unknown>(
+      "warehouse-zone-stacks",
+      "delete",
+      ({ id }) => warehouseService.removeStack(id).then((r) => r.data),
+      undefined,
+      ({ zoneId }) => [
+        ["warehouse-zone-stacks", zoneId],
+        ["warehouse-zones", zoneId, "layout"],
+        ["warehouse-zones", zoneId, "slot-summary"],
+      ],
+    ),
+
+    updateSlot: endpoint<
+      { slotId: string; zoneId: string; payload: { status?: string; isActive?: boolean } },
+      WarehouseZoneSlot
+    >(
+      "warehouse-zone-stacks",
+      "update-slot",
+      ({ slotId, payload }) => warehouseService.updateSlot(slotId, payload).then((r) => r.data),
+      undefined,
+      ({ zoneId }) => [
+        ["warehouse-zones", zoneId, "layout"],
+        ["warehouse-zones", zoneId, "slot-summary"],
+      ],
+    ),
+
+    deleteZone: endpoint<{ id: string }, unknown>(
+      "warehouses",
+      "deleteZone",
+      ({ id }) => warehouseService.removeZone(id).then((r) => r.data),
+      undefined,
+      () => [["warehouses"], ["warehouse-yards"]],
+    ),
+
     // ── Inventory (queries) ────────────────────────────────────────────────
     listInventory: endpoint<
       { filter?: InventoryFilter },
@@ -1454,7 +1577,7 @@ export const api = {
       "store",
       ({ id, payload }) => warehouseService.store(id, payload).then((r) => r.data),
       undefined,
-      () => INVENTORY_INVALIDATIONS,
+      () => [...INVENTORY_INVALIDATIONS, ["warehouse-zones"]],
     ),
 
     reserve: endpoint<ReserveInventoryPayload, WarehouseInventoryItem>(
@@ -1493,6 +1616,36 @@ export const api = {
       () => INVENTORY_INVALIDATIONS,
     ),
 
+    findAvailableSlot: endpoint<FindSlotPayload, AvailableSlot | null>(
+      "warehouse-inventory",
+      "find-slot",
+      (payload) => warehouseService.findAvailableSlot(payload).then((r) => r.data),
+      (payload) => ["warehouse-inventory", "find-slot", payload],
+    ),
+
+    containerAccessibility: endpoint<{ id: string }, ContainerAccessibility>(
+      "warehouse-inventory",
+      "accessibility",
+      ({ id }) => warehouseService.containerAccessibility(id).then((r) => r.data),
+      ({ id }) => ["warehouse-inventory", id, "accessibility"],
+    ),
+
+    assignSlot: endpoint<{ id: string; slotId?: string }, WarehouseInventoryItem>(
+      "warehouse-inventory",
+      "assign-slot",
+      ({ id, slotId }) => warehouseService.assignSlot(id, slotId).then((r) => r.data),
+      undefined,
+      () => [...INVENTORY_INVALIDATIONS, ["warehouse-zones"]],
+    ),
+
+    releaseSlot: endpoint<{ id: string }, WarehouseInventoryItem>(
+      "warehouse-inventory",
+      "release-slot",
+      ({ id }) => warehouseService.releaseSlot(id).then((r) => r.data),
+      undefined,
+      () => [...INVENTORY_INVALIDATIONS, ["warehouse-zones"]],
+    ),
+
     move: endpoint<
       { id: string; payload: MoveInventoryPayload },
       WarehouseInventoryItem
@@ -1502,7 +1655,7 @@ export const api = {
       ({ id, payload }) =>
         warehouseService.move(id, payload).then((r) => r.data),
       undefined,
-      () => INVENTORY_INVALIDATIONS,
+      () => [...INVENTORY_INVALIDATIONS, ["warehouse-zones"]],
     ),
 
     markReadyForPickup: endpoint<string, WarehouseInventoryItem>(
diff --git a/apps/edr-freight-web/backoffice/src/services/bookings.service.ts b/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
index 28c700529..4f2feeea3 100644
--- a/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/bookings.service.ts
@@ -73,6 +73,18 @@ export interface BookingListFilter {
   freightType?: string;
   /** Service type (rule-engine service_types.id). */
   serviceTypeId?: string;
+  /** Cargo type OR cargo group — a group matches every commodity beneath it. */
+  cargoTypeId?: string;
+  /** Contains-search over content: cargo description, commodity, container types. */
+  cargoText?: string;
+  /** Bookings carrying this container type; also scopes containersMin/Max to it. */
+  containerTypeId?: string;
+  /** Container count bounds — of containerTypeId when set, else of all types. */
+  containersMin?: string;
+  containersMax?: string;
+  /** Bounds on containers declared on the shipment request behind the booking. */
+  requestedContainersMin?: string;
+  requestedContainersMax?: string;
   /** ONE_TIME | GENERAL_CONTRACT — the booking-kind tab filter. */
   bookingType?: string;
   /** 'true' → customs bookings, 'false' → self-clearance (non-customs). */
@@ -199,6 +211,15 @@ export const bookingsService = {
       if (filter.companyId) params.companyId = filter.companyId;
       if (filter.freightType) params.freightType = filter.freightType;
       if (filter.serviceTypeId) params.serviceTypeId = filter.serviceTypeId;
+      if (filter.cargoTypeId) params.cargoTypeId = filter.cargoTypeId;
+      if (filter.cargoText) params.cargoText = filter.cargoText;
+      if (filter.containerTypeId) params.containerTypeId = filter.containerTypeId;
+      if (filter.containersMin) params.containersMin = filter.containersMin;
+      if (filter.containersMax) params.containersMax = filter.containersMax;
+      if (filter.requestedContainersMin)
+        params.requestedContainersMin = filter.requestedContainersMin;
+      if (filter.requestedContainersMax)
+        params.requestedContainersMax = filter.requestedContainersMax;
       if (filter.bookingType) params.bookingType = filter.bookingType;
       if (filter.tradeDirection) params.tradeDirection = filter.tradeDirection;
       if (filter.paymentCurrency)
@@ -238,6 +259,15 @@ export const bookingsService = {
       if (filter.contractId) params.contractId = filter.contractId;
       if (filter.freightType) params.freightType = filter.freightType;
       if (filter.serviceTypeId) params.serviceTypeId = filter.serviceTypeId;
+      if (filter.cargoTypeId) params.cargoTypeId = filter.cargoTypeId;
+      if (filter.cargoText) params.cargoText = filter.cargoText;
+      if (filter.containerTypeId) params.containerTypeId = filter.containerTypeId;
+      if (filter.containersMin) params.containersMin = filter.containersMin;
+      if (filter.containersMax) params.containersMax = filter.containersMax;
+      if (filter.requestedContainersMin)
+        params.requestedContainersMin = filter.requestedContainersMin;
+      if (filter.requestedContainersMax)
+        params.requestedContainersMax = filter.requestedContainersMax;
       if (filter.bookingType) params.bookingType = filter.bookingType;
       if (filter.tradeDirection) params.tradeDirection = filter.tradeDirection;
       if (filter.paymentCurrency)
diff --git a/apps/edr-freight-web/backoffice/src/services/importOperations.service.ts b/apps/edr-freight-web/backoffice/src/services/importOperations.service.ts
index 684862401..5911407d5 100644
--- a/apps/edr-freight-web/backoffice/src/services/importOperations.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/importOperations.service.ts
@@ -124,6 +124,17 @@ export const importOperationsService = {
     return unwrap(response.data);
   },
 
+  /** Backfill empties already in the yard. All-or-nothing on the server. */
+  bulkCreateEmptyReturns: async (
+    returns: CreateEmptyContainerReturnPayload[],
+  ): Promise<EmptyContainerReturn[]> => {
+    const response = await client.post<EmptyContainerReturn[]>(
+      URL_CONSTANTS.IMPORT_OPERATIONS.EMPTY_CONTAINER_RETURNS_BULK,
+      { returns },
+    );
+    return unwrap(response.data);
+  },
+
   loadEmptyContainersOnTrain: async (
     payload: LoadEmptyContainersOnTrainPayload,
   ): Promise<EmptyContainerReturn[]> => {
diff --git a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
index 382465e5a..f983baf15 100644
--- a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
@@ -33,6 +33,7 @@ import type {
   UpdateCheckpointPayload,
   DispatchSchedulePayload,
   StaffBookingWindow,
+  MarshallingStop,
   ScheduleMergePreview,
   TrainScheduleDetail,
   UpdateScheduleWindowRulePayload,
@@ -760,6 +761,24 @@ export const trainSchedulingService = {
     return response.data;
   },
 
+  getMarshallingStops: async (scheduleId: string): Promise<MarshallingStop[]> => {
+    const response = await client.get<MarshallingStop[]>(
+      URL_CONSTANTS.TRAIN_SCHEDULING.MARSHALLING_STOPS(scheduleId),
+    );
+    return unwrap(response.data);
+  },
+
+  downloadMarshallingDocumentAt: async (
+    scheduleId: string,
+    stopIndex: number,
+  ): Promise<Blob> => {
+    const response = await client.get(
+      URL_CONSTANTS.TRAIN_SCHEDULING.MARSHALLING_DOCUMENT_AT(scheduleId, stopIndex),
+      { responseType: "blob" },
+    );
+    return response.data;
+  },
+
   getTrack: async (scheduleId: string): Promise<TrainTrackResponse> => {
     const response = await client.get<TrainTrackResponse>(
       URL_CONSTANTS.TRAIN_SCHEDULING.CHECKPOINTS(scheduleId),
@@ -801,12 +820,13 @@ export const trainSchedulingService = {
   cancelSchedule: async (
     id: string,
     freightType: FreightType = "CONTAINER",
+    reason?: string,
   ): Promise<TrainScheduleDetail> => {
     const response = await client.post<TrainScheduleDetail>(
       pathsFor(
         freightType === "MIXED" ? undefined : freightType,
       ).CANCEL_SCHEDULE(id),
-      {},
+      { reason },
     );
     return unwrap(response.data);
   },
diff --git a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
index 14b7273f2..ad66776c3 100644
--- a/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/warehouse.service.ts
@@ -5,6 +5,14 @@ import { api as apiClient } from '../auth/http';
 import { URL_CONSTANTS } from '@/constants/URLS';
 import type {
   ZoneOccupancy,
+  ZoneLayout,
+  ZoneSlotSummary,
+  WarehouseZoneStack,
+  WarehouseZoneSlot,
+  SaveStackPayload,
+  AvailableSlot,
+  ContainerAccessibility,
+  FindSlotPayload,
   TruckOnSite,
   WarehouseOpsStats,
   WarehouseThroughputPoint,
@@ -41,6 +49,7 @@ import type {
   MoveInventoryPayload,
   StoreInventoryPayload,
   ReceiveInventoryPayload,
+  RegisterBacklogContainerPayload,
   ReleaseOrderPayload,
   DeliverInventoryPayload,
   EligibleBooking,
@@ -71,6 +80,7 @@ import type {
   WarehouseLoading,
   WarehouseYard,
   WarehouseZone,
+  ZoneContentItem,
 } from '@/types/warehouse';
 
 export type ContainerItemStage = 'PENDING' | 'RECEIVED' | 'GRN' | 'ASSIGNED' | 'LOADED' | 'LEFT' | 'DELIVERED';
@@ -257,6 +267,7 @@ export const warehouseService = {
     apiClient.post<Warehouse>(URL_CONSTANTS.WAREHOUSES.BASE, payload),
   update: (id: string, payload: Partial<SaveWarehousePayload>) =>
     apiClient.patch<Warehouse>(URL_CONSTANTS.WAREHOUSES.BY_ID(id), payload),
+  remove: (id: string) => apiClient.delete(URL_CONSTANTS.WAREHOUSES.BY_ID(id)),
   // Yards list now returns the standard paginated envelope ({ items, meta }).
   listFacilities: () =>
     apiClient.get<{ items: WarehouseFacility[] }>(URL_CONSTANTS.RULE_ENGINE.YARDS, {
@@ -272,6 +283,7 @@ export const warehouseService = {
   getYard: (id: string) => apiClient.get<WarehouseYard>(URL_CONSTANTS.WAREHOUSE_YARDS.BY_ID(id)),
   updateYard: (id: string, payload: Partial<SaveYardPayload>) =>
     apiClient.patch<WarehouseYard>(URL_CONSTANTS.WAREHOUSE_YARDS.BY_ID(id), payload),
+  removeYard: (id: string) => apiClient.delete(URL_CONSTANTS.WAREHOUSE_YARDS.BY_ID(id)),
 
   // ── Zones ──────────────────────────────────────────────────────────────
   listZones: (yardId: string) =>
@@ -282,6 +294,40 @@ export const warehouseService = {
   getZone: (id: string) => apiClient.get<WarehouseZone>(URL_CONSTANTS.WAREHOUSE_ZONES.BY_ID(id)),
   updateZone: (id: string, payload: Partial<SaveZonePayload>) =>
     apiClient.patch<WarehouseZone>(URL_CONSTANTS.WAREHOUSE_ZONES.BY_ID(id), payload),
+  removeZone: (id: string) => apiClient.delete(URL_CONSTANTS.WAREHOUSE_ZONES.BY_ID(id)),
+  zoneContents: (zoneId: string) =>
+    apiClient.get<ZoneContentItem[]>(`${URL_CONSTANTS.WAREHOUSE_ZONES.BY_ID(zoneId)}/contents`),
+  zoneLayout: (zoneId: string) =>
+    apiClient.get<ZoneLayout>(URL_CONSTANTS.WAREHOUSE_ZONES.LAYOUT(zoneId)),
+  zoneSlotSummary: (zoneId: string) =>
+    apiClient.get<ZoneSlotSummary>(URL_CONSTANTS.WAREHOUSE_ZONES.SLOT_SUMMARY(zoneId)),
+
+  // ── Ground stacks and slots ────────────────────────────────────────────
+  listStacks: (zoneId: string) =>
+    apiClient.get<WarehouseZoneStack[]>(URL_CONSTANTS.WAREHOUSE_ZONE_STACKS.BY_ZONE(zoneId)),
+  createStack: (zoneId: string, payload: SaveStackPayload) =>
+    apiClient.post<WarehouseZoneStack>(URL_CONSTANTS.WAREHOUSE_ZONE_STACKS.BASE, {
+      ...payload,
+      zoneId,
+    }),
+  updateStack: (id: string, payload: Partial<SaveStackPayload>) =>
+    apiClient.patch<WarehouseZoneStack>(URL_CONSTANTS.WAREHOUSE_ZONE_STACKS.BY_ID(id), payload),
+  removeStack: (id: string) =>
+    apiClient.delete(URL_CONSTANTS.WAREHOUSE_ZONE_STACKS.BY_ID(id)),
+  updateSlot: (slotId: string, payload: { status?: string; isActive?: boolean }) =>
+    apiClient.patch<WarehouseZoneSlot>(URL_CONSTANTS.WAREHOUSE_ZONE_STACKS.SLOT(slotId), payload),
+
+  // ── Physical placement ─────────────────────────────────────────────────
+  findAvailableSlot: (payload: FindSlotPayload) =>
+    apiClient.post<AvailableSlot | null>(URL_CONSTANTS.WAREHOUSE_INVENTORY.FIND_SLOT, payload),
+  assignSlot: (id: string, slotId?: string) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.ASSIGN_SLOT(id), {
+      slotId,
+    }),
+  releaseSlot: (id: string) =>
+    apiClient.post<WarehouseInventoryItem>(URL_CONSTANTS.WAREHOUSE_INVENTORY.RELEASE_SLOT(id), {}),
+  containerAccessibility: (id: string) =>
+    apiClient.get<ContainerAccessibility>(URL_CONSTANTS.WAREHOUSE_INVENTORY.ACCESSIBILITY(id)),
 
   // ── Inventory ──────────────────────────────────────────────────────────
   listInventory: (filter?: InventoryFilter) =>
@@ -351,6 +397,20 @@ export const warehouseService = {
   // ── Receive (Import/Export bulk) ─────────────────────────────────────────
   eligibleBookings: (direction?: 'IMPORT' | 'EXPORT') =>
     apiClient.get<EligibleBooking[]>(URL_CONSTANTS.WAREHOUSE_INVENTORY.ELIGIBLE_BOOKINGS(direction)),
+  /** Register one loaded container already in the yard but never entered. */
+  registerBacklogContainer: (payload: RegisterBacklogContainerPayload) =>
+    apiClient.post<WarehouseInventoryItem>(
+      URL_CONSTANTS.WAREHOUSE_INVENTORY.REGISTER_BACKLOG,
+      payload,
+    ),
+
+  /** Bulk backlog registration — all-or-nothing on the server. */
+  registerBacklogContainersBulk: (containers: RegisterBacklogContainerPayload[]) =>
+    apiClient.post<WarehouseInventoryItem[]>(
+      URL_CONSTANTS.WAREHOUSE_INVENTORY.REGISTER_BACKLOG_BULK,
+      { containers },
+    ),
+
   receiveBulk: (payload: BulkReceivePayload) =>
     apiClient.post<BulkReceiveResult>(URL_CONSTANTS.WAREHOUSE_INVENTORY.RECEIVE_BULK, payload),
   bulkMarkInspected: (payload: BulkInspectPayload) =>
diff --git a/apps/edr-freight-web/backoffice/src/types/importOperations.ts b/apps/edr-freight-web/backoffice/src/types/importOperations.ts
index ee8314d01..b4a034bfb 100644
--- a/apps/edr-freight-web/backoffice/src/types/importOperations.ts
+++ b/apps/edr-freight-web/backoffice/src/types/importOperations.ts
@@ -92,7 +92,11 @@ export interface EmptyContainerReturn {
   id: string;
   containerNumber: string;
   bookingId: string | null;
+  /** Reference of the booking this empty came back on; null for standalone returns. */
+  bookingReference: string | null;
   customerId: string | null;
+  /** Owning company as text — set for backfilled boxes whose company is unregistered. */
+  companyName: string | null;
   returnDate: string;
   facility: string | null;
   yard: string | null;
@@ -122,6 +126,7 @@ export interface CreateEmptyContainerReturnPayload {
   containerSize?: EmptyContainerSize;
   bookingId?: string;
   customerId?: string;
+  companyName?: string;
   returnDate?: string;
   facility?: string;
   yard?: string;
diff --git a/apps/edr-freight-web/backoffice/src/types/invoice.ts b/apps/edr-freight-web/backoffice/src/types/invoice.ts
index f33160a55..218e478fa 100644
--- a/apps/edr-freight-web/backoffice/src/types/invoice.ts
+++ b/apps/edr-freight-web/backoffice/src/types/invoice.ts
@@ -70,6 +70,8 @@ export interface InvoiceListFilter {
   statuses?: string;
   /** CSV of `Freight.InvoiceSource` values. */
   sources?: string;
+  /** CSV of invoice types (see `INVOICE_TYPE_OPTIONS`). */
+  types?: string;
   /** CSV of EIMS filing states. */
   eimsStatuses?: string;
   /** CSV of normalised UPPER_SNAKE payment methods (see `PAYMENT_METHOD_OPTIONS`). */
@@ -171,3 +173,28 @@ export function invoicePaymentMethod(invoice: Invoice): string | null {
 /** Human label for a method value; unknown values are shown as-is. */
 export const paymentMethodLabel = (method: string): string =>
   PAYMENT_METHOD_LABELS.get(method) ?? method;
+
+/**
+ * What an invoice bills for. Every billing source mints its own `type` string,
+ * so this list is the known vocabulary, not a closed enum — render an unknown
+ * value rather than treating it as invalid.
+ */
+export const INVOICE_TYPE_OPTIONS: { value: string; label: string }[] = [
+  { value: "PREPAID", label: "Prepaid freight" },
+  { value: "WAGON_CANCEL_FEE", label: "Wagon cancellation fee" },
+  { value: "GL_FINAL", label: "General contract final" },
+  { value: "ADDITIONAL_CHARGE", label: "Additional charge" },
+  { value: "PORT_CHARGES", label: "Port charges" },
+  { value: "MISCELLANEOUS", label: "Miscellaneous" },
+  { value: "DELIVERY_FEE", label: "Delivery fee" },
+  { value: "LAST_MILE_ADVANCE", label: "Last-mile advance" },
+  { value: "SHIPPING_LINE_CREDIT", label: "Shipping line credit" },
+  { value: "STORAGE_FEE", label: "Storage fee" },
+  { value: "DEMURRAGE", label: "Demurrage" },
+  { value: "MIXED_WAREHOUSE_FEES", label: "Mixed warehouse fees" },
+];
+
+/** Label for an invoice `type`, falling back to the humanised raw value. */
+export const invoiceTypeLabel = (type: string): string =>
+  INVOICE_TYPE_OPTIONS.find((o) => o.value === type)?.label ??
+  type.replace(/_/g, " ");
diff --git a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
index 7443e2ded..3536cddf9 100644
--- a/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
+++ b/apps/edr-freight-web/backoffice/src/types/trainScheduling.ts
@@ -287,6 +287,9 @@ export interface BookableSchedule {
   freightType?: FreightType | null;
   status: TrainScheduleStatus | string;
   bookingWindowStatus: "OPEN" | "FULL" | "CLOSED" | string;
+  /** Why the schedule was cancelled — null unless status is CANCELLED. */
+  cancellationReason?: string | null;
+  cancelledAt?: string | null;
   maxWagons: number;
   remainingWagons: number;
   locomotive: { id: string; code: string; name?: string | null } | null;
@@ -637,6 +640,9 @@ export interface TrainScheduleDetail {
   id: string;
   reference?: string | null;
   status: TrainScheduleStatus | string;
+  /** Why the schedule was cancelled — null unless status is CANCELLED. */
+  cancellationReason?: string | null;
+  cancelledAt?: string | null;
   deferredBookings?: DeferredBookingRow[];
   freightType?: FreightType | null;
   trainNumber?: string | null;
@@ -927,6 +933,19 @@ export interface TrainCheckpoint {
   note: string | null;
 }
 
+/**
+ * One corridor stop with a logged consist change (coupled/uncoupled/switched)
+ * — its own numbered marshalling document exists. `stopIndex` starts at 2;
+ * origin is always Marshalling 1 (the plain import/export load list, not
+ * this list). A stop with only a routine checkpoint never appears here.
+ */
+export interface MarshallingStop {
+  stopIndex: number;
+  yardId: string;
+  yardLabel: string;
+  firstOccurredAt: string;
+}
+
 /** The four station-work stamps, as a payload fragment both endpoints accept. */
 export interface CheckpointHandlingTimes {
   unloadingStartedAt?: string | null;
diff --git a/apps/edr-freight-web/backoffice/src/types/warehouse.ts b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
index b751a83cf..b17b728a9 100644
--- a/apps/edr-freight-web/backoffice/src/types/warehouse.ts
+++ b/apps/edr-freight-web/backoffice/src/types/warehouse.ts
@@ -145,6 +145,134 @@ export interface WarehouseYard {
   zones?: WarehouseZone[];
 }
 
+export const WAREHOUSE_STACK_STATUSES = ['ACTIVE', 'INACTIVE'] as const;
+export type WarehouseStackStatus = (typeof WAREHOUSE_STACK_STATUSES)[number];
+
+/** Stored slot intent. OCCUPIED is never stored — it is derived from inventory. */
+export const WAREHOUSE_SLOT_STATUSES = ['AVAILABLE', 'BLOCKED', 'RESERVED', 'INACTIVE'] as const;
+export type WarehouseSlotStatus = (typeof WAREHOUSE_SLOT_STATUSES)[number];
+
+export type SlotEffectiveStatus = WarehouseSlotStatus | 'OCCUPIED';
+
+/** One vertical level of a ground stack. */
+export interface WarehouseZoneSlot {
+  id: string;
+  stackId: string;
+  level: number;
+  status: WarehouseSlotStatus;
+  isActive: boolean;
+}
+
+/** One ground footprint inside a zone — where containers are stacked vertically. */
+export interface WarehouseZoneStack {
+  id: string;
+  zoneId: string;
+  code: string;
+  name: string | null;
+  row: string | null;
+  bay: string | null;
+  position: string | null;
+  maxStackHeight: number;
+  status: WarehouseStackStatus;
+  isActive: boolean;
+  slots?: WarehouseZoneSlot[];
+}
+
+export interface SaveStackPayload {
+  code: string;
+  name?: string;
+  row?: string;
+  bay?: string;
+  position?: string;
+  maxStackHeight?: number;
+  status?: WarehouseStackStatus;
+}
+
+/** Configured capacity vs slots actually built vs slots actually full. */
+export interface ZoneSlotSummary {
+  configuredCapacity: number | null;
+  physicalSlotCount: number;
+  occupiedSlotCount: number;
+  reservedSlotCount: number;
+  blockedSlotCount: number;
+  inactiveSlotCount: number;
+  availableSlotCount: number;
+  /** True when more slots are built than the configured capacity allows. */
+  inconsistent: boolean;
+}
+
+export interface ZoneLayoutSlot {
+  slotId: string;
+  level: number;
+  effectiveStatus: SlotEffectiveStatus;
+  inventoryId: string | null;
+  containerNumber: string | null;
+}
+
+export interface ZoneLayoutStack {
+  stackId: string;
+  code: string;
+  name: string | null;
+  maxStackHeight: number;
+  status: WarehouseStackStatus;
+  isActive: boolean;
+  /** Highest level first, the way the yard is seen from the side. */
+  slots: ZoneLayoutSlot[];
+}
+
+export interface ZoneLayout {
+  zoneId: string;
+  zoneCode: string;
+  zoneName: string;
+  stacks: ZoneLayoutStack[];
+  summary: ZoneSlotSummary;
+}
+
+export interface FindSlotPayload {
+  yardId: string;
+  zoneId?: string;
+  direction?: 'IMPORT' | 'EXPORT' | 'BOTH';
+  cargoTypeId?: string;
+}
+
+/** The lowest free stack level the placement engine would use next. */
+export interface AvailableSlot {
+  slotId: string;
+  stackId: string;
+  stackCode: string;
+  level: number;
+  zoneId: string;
+  zoneCode: string;
+}
+
+export interface BlockingContainer {
+  inventoryId: string;
+  containerNumber: string | null;
+  level: number;
+  status: string;
+}
+
+/** Whether a container can be lifted out, and what is stacked on top of it. */
+export interface ContainerAccessibility {
+  accessible: boolean;
+  inventoryId: string;
+  stackCode: string | null;
+  level: number | null;
+  blockingContainers: BlockingContainer[];
+}
+
+/** One container (or bulk lot) currently sitting in a zone. */
+export interface ZoneContentItem {
+  inventoryId: string;
+  containerNumber: string | null;
+  unloadedAt: string | null;
+  containerType: string | null;
+  direction: 'IMPORT' | 'EXPORT' | null;
+  loadState: string | null;
+  status: string;
+  bookingReference: string | null;
+}
+
 export const FACILITY_TYPES = [
   'PORT',
   'DRY_PORT',
@@ -168,11 +296,16 @@ export interface Facility {
 
 export type WarehouseFacility = Facility;
 
+/** What a warehouse handles. Null = both. */
+export const WAREHOUSE_FREIGHT_TYPES = ['CONTAINER', 'BULK'] as const;
+export type WarehouseFreightType = (typeof WAREHOUSE_FREIGHT_TYPES)[number];
+
 export interface Warehouse {
   id: string;
   name: string;
   code: string;
   type: WarehouseType;
+  freightType: WarehouseFreightType | null;
   stationId: string | null;
   facilityId: string | null;
   facility?: Facility | null;
@@ -365,6 +498,8 @@ export interface MoveInventoryPayload {
   warehouseId: string;
   yardId: string;
   zoneId: string;
+  /** Exact stack level in the destination zone. Container yards only. */
+  slotId?: string;
   remarks?: string;
 }
 
@@ -640,6 +775,8 @@ export interface StoreInventoryPayload {
   warehouseId?: string;
   yardId?: string;
   zoneId?: string;
+  /** Exact stack level. Omit to let the placement engine pick the lowest free one. */
+  slotId?: string;
 }
 
 export interface ImportTrainItem {
@@ -1031,6 +1168,7 @@ export interface SaveWarehousePayload {
   name: string;
   code: string;
   type: WarehouseType;
+  freightType?: WarehouseFreightType | null;
   stationId?: string;
   facilityId?: string;
   locationName?: string;
@@ -1063,6 +1201,26 @@ export interface SaveZonePayload {
   status?: WarehouseStatus;
 }
 
+/**
+ * A loaded container already sitting in a yard but never entered in the system.
+ * `arrivedAt` is the true historical arrival — the row is flagged as a backlog
+ * registration server-side and accrues no storage or demurrage.
+ */
+export interface RegisterBacklogContainerPayload {
+  containerNumber: string;
+  containerTypeId: string;
+  warehouseId: string;
+  yardId: string;
+  zoneId: string;
+  arrivedAt: string;
+  companyId?: string;
+  companyName?: string;
+  sealNumber?: string;
+  weight?: number;
+  volume?: number;
+  notes?: string;
+}
+
 export interface ReceiveInventoryPayload {
   warehouseId: string;
   yardId: string;
@@ -1082,6 +1240,8 @@ export interface MoveInventoryPayload {
   warehouseId: string;
   yardId: string;
   zoneId: string;
+  /** Exact stack level in the destination zone. Container yards only. */
+  slotId?: string;
   remarks?: string;
 }
 
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
index 544cc9449..61d162035 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
+++ b/apps/edr-freight-web/portal/src/pages/contracts/NewShipmentPage.tsx
@@ -595,7 +595,7 @@ function NewShipmentBookingForm({
                   : {}),
                 units: l.units.map((u) => ({
                   containerNumber: u.containerNumber,
-                  sealNumber: u.sealNumber || undefined,
+                  sealNumber: u.sealNumber.trim(),
                   vgmTons: Number(u.vgmTons),
                   // Per-container handling — the server rolls these up into the
                   // line counts and bills each surcharge on the ticked containers.
@@ -2309,7 +2309,7 @@ function ContainerLineEditor({
               Container number *
             </Text>
             <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
-              Seal number
+              Seal number *
             </Text>
             <Text fz={12} fw={600} c="#10202F" style={{ flex: 1 }}>
               VGM (tons) *
@@ -2355,10 +2355,11 @@ function ContainerLineEditor({
               <Controller
                 name={`containers.${index}.units.${u}.sealNumber`}
                 control={form.control}
-                render={({ field }) => (
+                render={({ field, fieldState }) => (
                   <TextInput
                     {...field}
-                    placeholder="Optional"
+                    placeholder="e.g. SL-0099231"
+                    error={fieldState.error?.message}
                     radius={10}
                     styles={fieldStyles}
                     style={{ flex: 1 }}
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/container-excel.test.ts b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/container-excel.test.ts
new file mode 100644
index 000000000..1c26329f6
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/container-excel.test.ts
@@ -0,0 +1,52 @@
+import { describe, expect, it } from "vitest";
+import * as XLSX from "xlsx";
+
+import { parseContainerExcel } from "./container-excel";
+
+// Seals became mandatory at booking time — a spreadsheet row without one must
+// reject the whole file, the same way a missing VGM already does.
+const OPTS = {
+  allowedSizes: ["20ft", "40ft"],
+  includeHazardous: false,
+  includeReefer: false,
+};
+
+function sheetFile(rows: string[][]): File {
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(
+    workbook,
+    XLSX.utils.aoa_to_sheet([
+      ["Container Size", "Container Number", "Seal Number", "VGM (Tons)"],
+      ...rows,
+    ]),
+    "Containers",
+  );
+  const buffer = XLSX.write(workbook, { type: "array", bookType: "xlsx" });
+  return new File([buffer], "containers.xlsx");
+}
+
+describe("parseContainerExcel", () => {
+  it("accepts a row carrying a seal", async () => {
+    const result = await parseContainerExcel(
+      sheetFile([["40ft", "MSCU1234567", "SL-0099231", "24.5"]]),
+      OPTS,
+    );
+
+    expect(result.errors).toEqual([]);
+    expect(result.rows).toHaveLength(1);
+    expect(result.rows[0].sealNumber).toBe("SL-0099231");
+  });
+
+  it("rejects the file when a row has no seal", async () => {
+    const result = await parseContainerExcel(
+      sheetFile([
+        ["40ft", "MSCU1234567", "SL-0099231", "24.5"],
+        ["20ft", "MSCU7654321", "", "12"],
+      ]),
+      OPTS,
+    );
+
+    expect(result.rows).toEqual([]);
+    expect(result.errors).toContain("Row 3: seal number is required.");
+  });
+});
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/container-excel.ts b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/container-excel.ts
index c00091bfc..fd34bd967 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/container-excel.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/container-excel.ts
@@ -151,6 +151,11 @@ export async function parseContainerExcel(
       numberCounts.set(containerNumber, (numberCounts.get(containerNumber) ?? 0) + 1);
     }
 
+    const sealNumber = cell("sealNumber");
+    if (!sealNumber) {
+      errors.push(`Row ${rowNo}: seal number is required.`);
+    }
+
     const vgmRaw = cell("vgmTons");
     const vgm = Number(vgmRaw);
     if (!vgmRaw || Number.isNaN(vgm) || vgm <= 0) {
@@ -160,7 +165,7 @@ export async function parseContainerExcel(
     rows.push({
       containerSize: size ?? "",
       containerNumber,
-      sealNumber: cell("sealNumber"),
+      sealNumber,
       vgmTons: vgmRaw,
       hazardous: opts.includeHazardous && parseFlag(cell("hazardous")),
       reefer: opts.includeReefer && parseFlag(cell("reefer")),
diff --git a/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts
index 5405347b0..121346d06 100644
--- a/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts
+++ b/apps/edr-freight-web/portal/src/pages/contracts/new-shipment-form/schema.ts
@@ -61,7 +61,9 @@ const containerUnitSchema = z.object({
       (v) => ISO_CONTAINER_NUMBER_REGEX.test(v.trim().toUpperCase()),
       "Enter a valid ISO container number (e.g. ABCD1234567).",
     ),
-  sealNumber: z.string().default(""),
+  sealNumber: z
+    .string()
+    .refine((v) => v.trim().length > 0, "Seal number is required."),
   vgmTons: z
     .string()
     .refine((v) => v.trim().length > 0, "VGM is required.")
diff --git a/apps/edr-passenger-api/prisma/migrations/20260821000001_add_reschedule/migration.sql b/apps/edr-passenger-api/prisma/migrations/20260821000001_add_reschedule/migration.sql
new file mode 100644
index 000000000..0d98e6d0e
--- /dev/null
+++ b/apps/edr-passenger-api/prisma/migrations/20260821000001_add_reschedule/migration.sql
@@ -0,0 +1,82 @@
+-- Rescheduling (passenger policy §3). One policy row per fare class — fare classes map 1:1 onto
+-- coach types (HSC = Standard, HBC = Flex, SBC = Premium) — plus a per-leg request table.
+-- Additive and idempotent; the seed below only inserts for coach types that exist.
+
+-- CreateTable
+CREATE TABLE IF NOT EXISTS "passenger"."ReschedulePolicy" (
+    "id"                 TEXT NOT NULL,
+    "coachTypeId"        TEXT NOT NULL,
+    "feePercent"         INTEGER NOT NULL DEFAULT 0,
+    "feeMinMinor"        INTEGER NOT NULL DEFAULT 0,
+    "routeChangeAllowed" BOOLEAN NOT NULL DEFAULT true,
+    "sameDayAllowed"     BOOLEAN NOT NULL DEFAULT true,
+    "sameDayFeePercent"  INTEGER NOT NULL DEFAULT 0,
+    "sameDayFeeMinMinor" INTEGER NOT NULL DEFAULT 0,
+    "cutoffMinutes"      INTEGER NOT NULL DEFAULT 60,
+    "isActive"           BOOLEAN NOT NULL DEFAULT true,
+    "createdAt"          TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt"          TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "ReschedulePolicy_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "ReschedulePolicy_coachTypeId_key" ON "passenger"."ReschedulePolicy"("coachTypeId");
+
+DO $$ BEGIN
+  ALTER TABLE "passenger"."ReschedulePolicy"
+    ADD CONSTRAINT "ReschedulePolicy_coachTypeId_fkey" FOREIGN KEY ("coachTypeId")
+    REFERENCES "passenger"."CoachType"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+
+-- CreateTable
+CREATE TABLE IF NOT EXISTS "passenger"."BookingReschedule" (
+    "id"                      TEXT NOT NULL,
+    "bookingId"               TEXT NOT NULL,
+    "leg"                     INTEGER NOT NULL DEFAULT 1,
+    "status"                  TEXT NOT NULL DEFAULT 'PENDING_PAYMENT',
+    "requestedBy"             TEXT NOT NULL,
+    "oldScheduleId"           TEXT NOT NULL,
+    "newScheduleId"           TEXT NOT NULL,
+    "oldOriginStationId"      TEXT,
+    "oldDestinationStationId" TEXT,
+    "newOriginStationId"      TEXT NOT NULL,
+    "newDestinationStationId" TEXT NOT NULL,
+    "oldSeatIds"              TEXT[],
+    "newSeatIds"              TEXT[],
+    "holdId"                  TEXT,
+    "oldFareMinor"            INTEGER NOT NULL,
+    "newFareMinor"            INTEGER NOT NULL,
+    "fareDifferenceMinor"     INTEGER NOT NULL,
+    "feeMinor"                INTEGER NOT NULL,
+    "amountDueMinor"          INTEGER NOT NULL,
+    "isSameDay"               BOOLEAN NOT NULL DEFAULT false,
+    "isRouteChange"           BOOLEAN NOT NULL DEFAULT false,
+    "supplementaryChargeId"   TEXT,
+    "expiresAt"               TIMESTAMP(3),
+    "appliedAt"               TIMESTAMP(3),
+    "createdAt"               TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "BookingReschedule_pkey" PRIMARY KEY ("id")
+);
+
+CREATE UNIQUE INDEX IF NOT EXISTS "BookingReschedule_supplementaryChargeId_key" ON "passenger"."BookingReschedule"("supplementaryChargeId");
+CREATE INDEX IF NOT EXISTS "BookingReschedule_bookingId_status_idx" ON "passenger"."BookingReschedule"("bookingId", "status");
+
+DO $$ BEGIN
+  ALTER TABLE "passenger"."BookingReschedule"
+    ADD CONSTRAINT "BookingReschedule_bookingId_fkey" FOREIGN KEY ("bookingId")
+    REFERENCES "passenger"."Booking"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+EXCEPTION WHEN duplicate_object THEN NULL; END $$;
+
+-- Seed the policy doc's §3 values. Same-day fee is stored as an absolute rule per class:
+-- Flex's "50% of the Standard fee" (30% / min 500 ETB) is 15% / min 250 ETB.
+INSERT INTO "passenger"."ReschedulePolicy"
+  ("id", "coachTypeId", "feePercent", "feeMinMinor", "routeChangeAllowed", "sameDayAllowed", "sameDayFeePercent", "sameDayFeeMinMinor", "cutoffMinutes", "updatedAt")
+SELECT gen_random_uuid()::text, ct."id", v."feePercent", v."feeMinMinor", v."routeChangeAllowed", v."sameDayAllowed", v."sameDayFeePercent", v."sameDayFeeMinMinor", v."cutoffMinutes", CURRENT_TIMESTAMP
+FROM (VALUES
+  ('HSC', 30, 50000, false, false,  0,     0, 120),
+  ('HBC',  0,     0, true,  true,  15, 25000,  60),
+  ('SBC',  0,     0, true,  true,   0,     0,  60)
+) AS v("code", "feePercent", "feeMinMinor", "routeChangeAllowed", "sameDayAllowed", "sameDayFeePercent", "sameDayFeeMinMinor", "cutoffMinutes")
+JOIN "passenger"."CoachType" ct ON ct."code" = v."code"
+ON CONFLICT ("coachTypeId") DO NOTHING;
diff --git a/apps/edr-passenger-api/prisma/schema.prisma b/apps/edr-passenger-api/prisma/schema.prisma
index 22bfa8f40..693bf1fb2 100644
--- a/apps/edr-passenger-api/prisma/schema.prisma
+++ b/apps/edr-passenger-api/prisma/schema.prisma
@@ -80,6 +80,7 @@ model CoachType {
   updatedAt   DateTime    @updatedAt
   coaches     Coach[]
   seatClasses SeatClass[]
+  reschedulePolicy ReschedulePolicy?
   @@schema("passenger")
 }
 
@@ -568,6 +569,7 @@ model Booking {
   foodOrders                FoodOrder[]
   agentBooking              AgentBooking?
   modifications             BookingModification[]
+  reschedules               BookingReschedule[]
   cancellation              BookingCancellation?
   baggage                   BaggageBooking[]
   excessBaggageCharges      ExcessBaggageCharge[]
@@ -1205,6 +1207,61 @@ model AgentCommission {
   @@schema("passenger")
 }
 
+/// Rescheduling rule per fare class. Fare families from the passenger policy map 1:1 onto
+/// coach types (HSC = Standard, HBC = Flex, SBC = Premium). Seeded by migration from the policy
+/// doc; edited in backoffice Settings → Reschedule Policy.
+model ReschedulePolicy {
+  id                 String    @id @default(uuid())
+  coachTypeId        String    @unique
+  feePercent         Int       @default(0)        // % of the leg's original fare
+  feeMinMinor        Int       @default(0)        // fee floor, ETB minor units
+  routeChangeAllowed Boolean   @default(true)
+  sameDayAllowed     Boolean   @default(true)
+  sameDayFeePercent  Int       @default(0)        // same-day change: % of the leg's original fare (replaces feePercent)
+  sameDayFeeMinMinor Int       @default(0)        // same-day change: fee floor, ETB minor units
+  cutoffMinutes      Int       @default(60)       // reject when departure - now < this
+  isActive           Boolean   @default(true)
+  createdAt          DateTime  @default(now())
+  updatedAt          DateTime  @updatedAt
+  coachType          CoachType @relation(fields: [coachTypeId], references: [id])
+
+  @@schema("passenger")
+}
+
+/// One reschedule request for one leg of a booking. PENDING_PAYMENT while the supplementary
+/// charge is unpaid; APPLIED once the booking was moved; EXPIRED when the payment deadline passed.
+model BookingReschedule {
+  id                      String    @id @default(uuid())
+  bookingId               String
+  leg                     Int       @default(1)   // 1 = outbound, 2 = return
+  status                  String    @default("PENDING_PAYMENT") // PENDING_PAYMENT | APPLIED | EXPIRED
+  requestedBy             String                   // passengerId or IAM user id
+  oldScheduleId           String
+  newScheduleId           String
+  oldOriginStationId      String?
+  oldDestinationStationId String?
+  newOriginStationId      String
+  newDestinationStationId String
+  oldSeatIds              String[]
+  newSeatIds              String[]
+  holdId                  String?
+  oldFareMinor            Int
+  newFareMinor            Int
+  fareDifferenceMinor     Int                      // new - old; negative = forfeited for now
+  feeMinor                Int
+  amountDueMinor          Int                      // fee + max(0, difference)
+  isSameDay               Boolean   @default(false)
+  isRouteChange           Boolean   @default(false)
+  supplementaryChargeId   String?   @unique
+  expiresAt               DateTime?
+  appliedAt               DateTime?
+  createdAt               DateTime  @default(now())
+  booking                 Booking   @relation(fields: [bookingId], references: [id])
+
+  @@index([bookingId, status])
+  @@schema("passenger")
+}
+
 model BookingModification {
   id               String   @id @default(uuid())
   bookingId        String
diff --git a/apps/edr-passenger-api/prisma/seed.ts b/apps/edr-passenger-api/prisma/seed.ts
index 313ce34b0..8768ba899 100644
--- a/apps/edr-passenger-api/prisma/seed.ts
+++ b/apps/edr-passenger-api/prisma/seed.ts
@@ -657,6 +657,7 @@ async function seedNotificationTemplates() {
     { id: uuidv4(), code: 'payment.succeeded', channel: 'SMS', subject: 'Payment Received', bodyTemplate: 'Payment of {{amount}} {{currency}} received for booking {{bookingRef}}.' },
     { id: uuidv4(), code: 'payment.failed', channel: 'SMS', subject: 'Payment Failed', bodyTemplate: 'Payment for booking {{bookingRef}} could not be completed. Please try again.' },
     { id: uuidv4(), code: 'booking.cancelled', channel: 'EMAIL', subject: 'Booking Cancelled', bodyTemplate: 'Your booking {{bookingRef}} has been cancelled. Refund: {{refundAmount}} {{currency}}.' },
+    { id: uuidv4(), code: 'booking.rescheduled', channel: 'EMAIL', subject: 'Booking Rescheduled', bodyTemplate: 'Your {{leg}} journey on booking {{bookingRef}} has been rescheduled. New tickets have been issued. Change fee: {{feeAmount}} {{currency}}.' },
     // Templates below are not wired to handlers yet (Phase 2 — full event coverage).
     { id: uuidv4(), code: 'trip.departure', channel: 'PUSH', subject: 'Trip Departing Soon', bodyTemplate: 'Your trip {{route}} departs in {{minutes}} minutes' },
     { id: uuidv4(), code: 'trip.delay', channel: 'EMAIL', subject: 'Trip Delayed', bodyTemplate: 'Your trip {{route}} is delayed by {{delayMinutes}} minutes' },
diff --git a/apps/edr-passenger-api/src/app.module.ts b/apps/edr-passenger-api/src/app.module.ts
index e3b85c21f..ff77b8b07 100644
--- a/apps/edr-passenger-api/src/app.module.ts
+++ b/apps/edr-passenger-api/src/app.module.ts
@@ -64,6 +64,7 @@ import { ConfigurableFareModule } from "./modules/configurable-fare/configurable
 import { SegmentFareSeeder } from "./seed/segment-fare.seeder";
 
 import { EOtpType } from "@tria-plc/iamapi-common";
+import { RescheduleModule } from './modules/reschedule/reschedule.module';
 
 @Module({
   imports: [
@@ -164,6 +165,7 @@ import { EOtpType } from "@tria-plc/iamapi-common";
     TasksModule,
     AppReleasesModule,
     ConfigurableFareModule,
+    RescheduleModule,
   ],
   providers: [
     { provide: APP_FILTER, useClass: DeleteExceptionFilter },
diff --git a/apps/edr-passenger-api/src/common/audit.actions.ts b/apps/edr-passenger-api/src/common/audit.actions.ts
index f9ee389db..8ac818e48 100644
--- a/apps/edr-passenger-api/src/common/audit.actions.ts
+++ b/apps/edr-passenger-api/src/common/audit.actions.ts
@@ -86,6 +86,8 @@ export const AUDIT_ENTITIES = {
   // Operations
   Ticket: 'Ticket',
   Booking: 'Booking',
+  BookingReschedule: 'BookingReschedule',
+  ReschedulePolicy: 'ReschedulePolicy',
 } as const;
 
 export type AuditEntity = (typeof AUDIT_ENTITIES)[keyof typeof AUDIT_ENTITIES];
diff --git a/apps/edr-passenger-api/src/common/passenger-permission.util.ts b/apps/edr-passenger-api/src/common/passenger-permission.util.ts
index cc94b0e0c..628d39dfe 100644
--- a/apps/edr-passenger-api/src/common/passenger-permission.util.ts
+++ b/apps/edr-passenger-api/src/common/passenger-permission.util.ts
@@ -28,7 +28,7 @@ type EmployeeLike = {
   delegatedPositions?: PositionLike[];
 };
 
-type MeLikeUser = {
+export type MeLikeUser = {
   roles?: { key?: string }[];
   permissions?: PermissionLike[];
   employee?: EmployeeLike | EmployeeLike[] | null;
diff --git a/apps/edr-passenger-api/src/common/utils/phone.utils.ts b/apps/edr-passenger-api/src/common/utils/phone.utils.ts
index 73ca8dc16..501d86427 100644
--- a/apps/edr-passenger-api/src/common/utils/phone.utils.ts
+++ b/apps/edr-passenger-api/src/common/utils/phone.utils.ts
@@ -1,15 +1,3 @@
-/**
- * Phone normalisation shared by any lookup that has to match a number a customer typed
- * against one already stored. Ethiopian numbers reach us in three interchangeable shapes
- * (+2519…, 2519…, 09…) depending on whether they came from IAM, a guest booking form or a
- * saved profile, so an exact-string match silently misses.
- */
-
-/**
- * Returns all plausible normalised variants of a raw phone string so that the
- * DB query matches regardless of how the number was stored (local 09… vs international +251…).
- * Returns an empty array when the input is clearly invalid (< 7 digits).
- */
 export function normalizePhoneVariants(raw: string): string[] {
   // Strip whitespace, dashes, dots, parentheses — keep digits and a leading +
   const stripped = raw.replace(/[^\d+]/g, '');
@@ -38,13 +26,6 @@ export function normalizePhoneVariants(raw: string): string[] {
   return [...variants];
 }
 
-/**
- * A sign-in identifier is a single free-text field: the passenger types either an email
- * address or a phone number and the server works out which. Phone is the default reading —
- * an email must contain an `@` with something either side of it, everything else is treated
- * as a number so that malformed emails don't silently fall through to a phone lookup that
- * can never match.
- */
 export type ResolvedIdentifier = {
   kind: 'email' | 'phone';
   /** Lower-cased email, or null when the input is a phone number. */
@@ -75,3 +56,27 @@ export function maskPhone(phone: string): string {
   const tail = stripped.slice(-3);
   return `${head}${'*'.repeat(4)}${tail}`;
 }
+
+/**
+ * Collapses a number to a single canonical E.164 form so two values can be compared directly.
+ * Mirrors `PassengerAuthService.standardizePhone`, plus the bare-9-digit case the passenger
+ * form produces (its input sits behind a fixed `+251` prefix control).
+ *
+ */
+export function normalizePhone(phone?: string | null): string | null {
+  if (!phone) return null;
+  const digits = phone.replace(/\D/g, '');
+  if (!digits) return null;
+  if (digits.startsWith('251')) return `+${digits}`;
+  if (digits.startsWith('0')) return `+251${digits.slice(1)}`;
+  // A bare local subscriber number, e.g. "912345678" from the +251-prefixed input.
+  if (digits.length === 9) return `+251${digits}`;
+  return `+${digits}`;
+}
+
+/** True only when both numbers are present and resolve to the same E.164 form. */
+export function samePhone(a?: string | null, b?: string | null): boolean {
+  const left = normalizePhone(a);
+  const right = normalizePhone(b);
+  return !!left && !!right && left === right;
+}
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
index 2aff404b8..ecd3b4043 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.controller.ts
@@ -26,7 +26,6 @@ import { BookingsService } from "./bookings.service";
 import { GuestBookingService } from "./guest-booking.service";
 import {
   CreateBookingDto,
-  ModifyBookingDto,
   CancelBookingDto,
 } from "./bookings.dto";
 import {
@@ -692,22 +691,6 @@ Results are ordered most-recent first. Use the returned \`bookingRef\` to open b
     return this.service.getByRef(ref);
   }
 
-  @Patch(":bookingRef/modify")
-  @UseGuards(JwtGuard)
-  @ApiBearerAuth("JWT-auth")
-  @ApiOperation({
-    summary: "Modify booking seats or trip",
-    description: "Allows modification of confirmed bookings before departure",
-  })
-  @ApiResponse({ status: 200, description: "Booking modified successfully" })
-  @ApiResponse({
-    status: 400,
-    description: "Cannot modify cancelled or past bookings",
-  })
-  modify(@Req() req: any, @Body() dto: ModifyBookingDto) {
-    return this.service.modify(dto, req.user?.id);
-  }
-
   @Delete(":id")
   @PassengerAdmin()
   @ApiBearerAuth("IAM-auth")
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
index 454339516..5e9d98d11 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.dto.ts
@@ -214,13 +214,6 @@ export class CreateBookingDto {
   @IsOptional() @IsString() returnLeg2SeatClassId?: string;
 }
 
-export class ModifyBookingDto {
-  @ApiProperty() @IsString() bookingRef: string;
-  @ApiProperty({ example: 'schedule-uuid' }) @IsString() newScheduleId: string;
-  @ApiProperty({ type: [String] }) @IsArray() newSeatIds: string[];
-  @ApiPropertyOptional() @IsOptional() @IsString() reason?: string;
-}
-
 export class CancelBookingDto {
   @ApiProperty() @IsString() bookingRef: string;
   @ApiPropertyOptional() @IsOptional() @IsString() reason?: string;
diff --git a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
index 01367bdb1..7a447690a 100644
--- a/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-passenger-api/src/modules/bookings/bookings.service.ts
@@ -5,8 +5,9 @@ import { PrismaService } from '../../common/prisma.service';
 import { SeatsService } from '../seats/seats.service';
 import { TicketsService } from '../tickets/tickets.service';
 import { EventEmitter2 } from '@nestjs/event-emitter';
-import { CreateBookingDto, ModifyBookingDto } from './bookings.dto';
+import { CreateBookingDto } from './bookings.dto';
 import { assertIdentitiesNotAlreadyBooked, resolveIdentityRef } from './booking-identity.util';
+import { buildPaymentBreakdown } from './payment-breakdown.util';
 import { Cron, CronExpression } from '@nestjs/schedule';
 import { VerifaydaService } from '../verifayda/verifayda.service';
 import { CurrencyService } from '../currency/currency.service';
@@ -1873,7 +1874,7 @@ export class BookingsService {
     };
   }
 
-  private async getBaseFare(
+  async getBaseFare(
     scheduleId: string,
     seatClassId: string,
     segmentRoute?: string,
@@ -2005,6 +2006,8 @@ export class BookingsService {
         returnSchedule: { include: { originStation: true, destinationStation: true, train: true, stopTimes: { include: { station: true } } } },
         seats: { include: { seat: { include: { coach: { include: { coachType: { include: { seatClasses: true } } } } } } } },
         paymentIntent: true, tickets: true,
+        // Money collected after the original payment (reschedule fees, underpayments).
+        supplementaryCharges: { orderBy: { createdAt: 'asc' } },
         priceTier: { select: { priceMinor: true } },
       },
     });
@@ -2098,6 +2101,8 @@ export class BookingsService {
           returnSchedule: { include: { originStation: true, destinationStation: true, train: true, stopTimes: { include: { station: true } } } },
           seats: { include: { seat: { include: { coach: { include: { coachType: { include: { seatClasses: true } } } } } } } },
           paymentIntent: true, tickets: true,
+        // Money collected after the original payment (reschedule fees, underpayments).
+        supplementaryCharges: { orderBy: { createdAt: 'asc' } },
           priceTier: { select: { priceMinor: true } },
         },
       });
@@ -2176,12 +2181,20 @@ export class BookingsService {
           },
         };
       }),
+      // `amountMinor` stays exactly as it was — the original intent, in the major units that
+      // column actually stores — so existing callers keep working. Everything collected since
+      // (reschedule fees and fare differences) lives in `breakdown`, whose `totalPaidMinor` is
+      // the number to show as "Total paid". See payment-breakdown.util.ts.
       payment: (booking as any).paymentIntent
         ? {
             method: (booking as any).paymentIntent.method,
             status: (booking as any).paymentIntent.status,
             amountMinor: (booking as any).paymentIntent.amountMinor,
             currency: (booking as any).paymentIntent.currency,
+            breakdown: buildPaymentBreakdown(
+              (booking as any).paymentIntent,
+              (booking as any).supplementaryCharges ?? [],
+            ),
           }
         : undefined,
       // One ticket per passenger per leg (round trips have a separate ticket — and
@@ -2199,22 +2212,6 @@ export class BookingsService {
     };
   }
 
-  async modify(dto: ModifyBookingDto, iamUserId?: string) {
-    const booking = await this.prisma.booking.findUnique({ where: { bookingRef: dto.bookingRef }, include: { seats: true, schedule: true } });
-    if (!booking) throw new NotFoundException('Booking not found');
-    if (booking.status !== 'CONFIRMED') throw new BadRequestException('Only confirmed bookings can be modified');
-    if (booking.schedule.departureAt < new Date()) throw new BadRequestException('Cannot modify past bookings');
-
-    const oldSeats = booking.seats.map(s => s.seatId);
-    await this.prisma.bookingModification.create({
-      data: { bookingId: booking.id, modifiedBy: booking.passengerId, modificationType: 'SEAT_CHANGE', oldData: { scheduleId: booking.scheduleId, seatIds: oldSeats }, newData: { scheduleId: dto.newScheduleId, seatIds: dto.newSeatIds }, fareAdjustment: 0, reason: dto.reason },
-    });
-    await this.seatsService.releaseSeats(booking.id);
-    await this.seatsService.confirmSeats(dto.newSeatIds);
-    await this.auditService.log({ userId: iamUserId ?? booking.passengerId, action: 'UPDATE', entityType: 'Booking', entityId: booking.id, oldData: { seatIds: oldSeats }, newData: { seatIds: dto.newSeatIds, reason: dto.reason } });
-    return { modified: true, bookingRef: dto.bookingRef };
-  }
-
   async cancel(bookingRef: string, reason?: string, iamUserId?: string) {
     const booking = await this.prisma.booking.findUnique({ where: { bookingRef }, include: { seats: true, paymentIntent: true } });
     if (!booking) throw new NotFoundException('Booking not found');
diff --git a/apps/edr-passenger-api/src/modules/bookings/payment-breakdown.util.ts b/apps/edr-passenger-api/src/modules/bookings/payment-breakdown.util.ts
new file mode 100644
index 000000000..0980fcc97
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/bookings/payment-breakdown.util.ts
@@ -0,0 +1,101 @@
+export type PaymentLineKind = 'BOOKING' | 'SUPPLEMENTARY';
+
+export interface PaymentLine {
+  kind: PaymentLineKind;
+  /** Human label — "Original booking", "Reschedule", "Excess baggage". */
+  label: string;
+  /** Raw reason for supplementary lines (RESCHEDULE, UNDERPAYMENT, …); null for the booking line. */
+  reason: string | null;
+  /** Always true minor units, whatever the source column stored. */
+  amountMinor: number;
+  currency: string;
+  status: string;
+  paidAt: string | null;
+  /** Whether this line represents money actually collected. */
+  settled: boolean;
+}
+
+export interface PaymentBreakdown {
+  lines: PaymentLine[];
+  /** Sum of settled lines, or null when they are not all in one currency. */
+  totalPaidMinor: number | null;
+  totalPaidCurrency: string | null;
+  /** True when something is still owed (a charge raised but not yet paid). */
+  hasOutstanding: boolean;
+  outstandingMinor: number;
+}
+
+/** `PaymentIntent.amountMinor` is a Float in major units — bring it onto the minor-unit scale. */
+export function intentAmountToMinor(amount: number | null | undefined): number {
+  if (amount == null) return 0;
+  return Math.round(amount * 100);
+}
+
+const SUPPLEMENTARY_LABELS: Record<string, string> = {
+  RESCHEDULE: 'Reschedule',
+  UNDERPAYMENT: 'Underpayment',
+  FARE_CORRECTION: 'Fare correction',
+  EXCESS_BAGGAGE: 'Excess baggage',
+};
+
+function labelFor(reason: string): string {
+  return (
+    SUPPLEMENTARY_LABELS[reason] ??
+    // "SOME_OTHER_REASON" → "Some other reason"
+    reason.charAt(0).toUpperCase() + reason.slice(1).toLowerCase().replace(/_/g, ' ')
+  );
+}
+
+export function buildPaymentBreakdown(
+  paymentIntent: { status?: string | null; amountMinor?: number | null; currency?: string | null } | null | undefined,
+  supplementaryCharges: Array<{
+    reason: string;
+    amountMinor: number;
+    currency: string;
+    status: string;
+    paidAt: Date | string | null;
+  }> = [],
+): PaymentBreakdown {
+  const lines: PaymentLine[] = [];
+
+  if (paymentIntent) {
+    lines.push({
+      kind: 'BOOKING',
+      label: 'Original booking',
+      reason: null,
+      amountMinor: intentAmountToMinor(paymentIntent.amountMinor),
+      currency: paymentIntent.currency ?? 'ETB',
+      status: paymentIntent.status ?? 'UNKNOWN',
+      paidAt: null,
+      settled: paymentIntent.status === 'SUCCEEDED',
+    });
+  }
+
+  for (const charge of supplementaryCharges) {
+    if (charge.status === 'WAIVED' || charge.status === 'EXPIRED') continue;
+    lines.push({
+      kind: 'SUPPLEMENTARY',
+      label: labelFor(charge.reason),
+      reason: charge.reason,
+      amountMinor: charge.amountMinor,
+      currency: charge.currency ?? 'ETB',
+      status: charge.status,
+      paidAt: charge.paidAt ? new Date(charge.paidAt).toISOString() : null,
+      settled: charge.status === 'PAID',
+    });
+  }
+
+  const settled = lines.filter((l) => l.settled);
+  const currencies = new Set(settled.map((l) => l.currency));
+  const singleCurrency = currencies.size === 1 ? [...currencies][0] : null;
+
+  const outstanding = lines.filter((l) => l.status === 'PENDING');
+
+  return {
+    lines,
+    totalPaidMinor: singleCurrency ? settled.reduce((sum, l) => sum + l.amountMinor, 0) : null,
+    totalPaidCurrency: singleCurrency,
+    hasOutstanding: outstanding.length > 0,
+    outstandingMinor: outstanding.reduce((sum, l) => sum + l.amountMinor, 0),
+  };
+}
diff --git a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
index 3b7e7be2f..44ba03dea 100644
--- a/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
+++ b/apps/edr-passenger-api/src/modules/notifications/notifications.service.ts
@@ -731,6 +731,24 @@ export class NotificationsService {
     );
   }
 
+  @OnEvent('booking.rescheduled')
+  async onBookingRescheduled(payload: any) {
+    const { booking, reschedule } = payload;
+    await this.send(
+      'booking.rescheduled',
+      booking.passengerId,
+      {
+        bookingRef: booking.bookingRef,
+        leg: reschedule?.leg === 2 ? 'return' : 'outbound',
+        feeAmount: ((reschedule?.feeMinor ?? 0) / 100).toFixed(2),
+        currency: 'ETB',
+        category: 'BOOKING',
+        deepLink: `edr://bookings/${booking.bookingRef}`,
+      },
+      ['IN_APP', 'EMAIL', 'SMS'],
+    );
+  }
+
   @OnEvent('booking.cancelled')
   async onBookingCancelled(payload: any) {
     const booking = payload.booking;
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.module.ts b/apps/edr-passenger-api/src/modules/payments/payments.module.ts
index 07f452e43..970983cb4 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.module.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.module.ts
@@ -74,6 +74,6 @@ function rabbitMQImport(): DynamicModule[] {
     PaymentSyncService,
     ServiceAuthGuard,
   ],
-  exports: [PaymentClientService, PaymentsService],
+  exports: [PaymentClientService, PaymentsService, SupplementaryChargesService],
 })
 export class PaymentsModule {}
diff --git a/apps/edr-passenger-api/src/modules/payments/payments.service.ts b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
index 7192c7fc7..ced758d98 100644
--- a/apps/edr-passenger-api/src/modules/payments/payments.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/payments.service.ts
@@ -1619,6 +1619,7 @@ export class PaymentsService {
           settledCurrency: event.currency,
         },
       });
+      this.eventEmitter.emit("supplementary-charge.paid", { chargeId: charge.id });
     }
     return { processed: true, alreadyFinalized: count === 0 };
   }
@@ -1996,7 +1997,7 @@ export class PaymentsService {
     });
   }
 
-  private async createJourneySegments(
+  async createJourneySegments(
     booking: Prisma.BookingGetPayload<{ include: { seats: true } }>,
   ) {
     const b = booking as any;
diff --git a/apps/edr-passenger-api/src/modules/payments/supplementary-charges-audit.spec.ts b/apps/edr-passenger-api/src/modules/payments/supplementary-charges-audit.spec.ts
index 28188f70f..24e112548 100644
--- a/apps/edr-passenger-api/src/modules/payments/supplementary-charges-audit.spec.ts
+++ b/apps/edr-passenger-api/src/modules/payments/supplementary-charges-audit.spec.ts
@@ -52,7 +52,7 @@ describe('SupplementaryChargesService — audit', () => {
     };
     audit = { log: jest.fn().mockResolvedValue(undefined) };
 
-    // Constructor order: prisma, audit, sms, email, paymentClient, currency.
+    // Constructor order: prisma, audit, sms, email, paymentClient, currency, eventEmitter.
     service = new SupplementaryChargesService(
       prisma as any,
       audit as any,
@@ -60,6 +60,7 @@ describe('SupplementaryChargesService — audit', () => {
       { sendEmail: jest.fn() } as any,
       {} as any,
       {} as any,
+      { emit: jest.fn() } as any,
     );
     return row;
   };
diff --git a/apps/edr-passenger-api/src/modules/payments/supplementary-charges.service.ts b/apps/edr-passenger-api/src/modules/payments/supplementary-charges.service.ts
index 184ff69ad..30460c8b8 100644
--- a/apps/edr-passenger-api/src/modules/payments/supplementary-charges.service.ts
+++ b/apps/edr-passenger-api/src/modules/payments/supplementary-charges.service.ts
@@ -14,6 +14,7 @@ import {
 } from '@edr/types';
 import { PaymentPlatformDto } from './payments.dto';
 import { PaymentMethodType } from '@prisma/client';
+import { EventEmitter2 } from '@nestjs/event-emitter';
 
 const CHARGE_TTL_MS = 72 * 60 * 60 * 1000; // 72 hours
 
@@ -45,6 +46,7 @@ export class SupplementaryChargesService {
     private emailClient: EmailClientService,
     private paymentClient: PaymentClientService,
     private currencyService: CurrencyService,
+    private eventEmitter: EventEmitter2,
   ) {}
 
   async create(dto: {
@@ -55,6 +57,8 @@ export class SupplementaryChargesService {
     contactPhone?: string;
     contactEmail?: string;
     createdBy: string;
+    /** Overrides the default 72h link lifetime (a reschedule charge must die with its seat hold). */
+    expiresAt?: Date;
   }) {
     const booking = await this.prisma.booking.findUnique({
       where: { bookingRef: dto.bookingRef },
@@ -66,7 +70,7 @@ export class SupplementaryChargesService {
     }
     if (dto.amountMinor <= 0) throw new BadRequestException('Amount must be positive');
 
-    const expiresAt = new Date(Date.now() + CHARGE_TTL_MS);
+    const expiresAt = dto.expiresAt ?? new Date(Date.now() + CHARGE_TTL_MS);
     const charge = await this.prisma.supplementaryCharge.create({
       data: {
         bookingId: booking.id,
@@ -172,6 +176,7 @@ export class SupplementaryChargesService {
           providerTxnId: providerTxnId ?? null,
         },
       });
+      this.eventEmitter.emit('supplementary-charge.paid', { chargeId: id });
     }
 
     return updated!;
diff --git a/apps/edr-passenger-api/src/modules/payments/supplementary-charges.spec.ts b/apps/edr-passenger-api/src/modules/payments/supplementary-charges.spec.ts
index 043ec919c..bd72b649b 100644
--- a/apps/edr-passenger-api/src/modules/payments/supplementary-charges.spec.ts
+++ b/apps/edr-passenger-api/src/modules/payments/supplementary-charges.spec.ts
@@ -69,6 +69,7 @@ describe('SupplementaryChargesService — payment methods', () => {
       {} as any,
       paymentClient as any,
       new CurrencyService(prisma as any),
+      { emit: jest.fn() } as any,
     );
   };
 
diff --git a/apps/edr-passenger-api/src/modules/reschedule/reschedule.controller.ts b/apps/edr-passenger-api/src/modules/reschedule/reschedule.controller.ts
new file mode 100644
index 000000000..0aba110d1
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/reschedule/reschedule.controller.ts
@@ -0,0 +1,82 @@
+import { Body, Controller, Delete, Get, Param, Patch, Post, Req, UseGuards } from '@nestjs/common';
+import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+import { JwtGuard } from '../../common/jwt.guard';
+import { PassengerAdmin, PassengerStaff } from '../../common/passenger-guards';
+import { PASSENGER_PERMS } from '../../seed/passenger-permissions.registry';
+import { RescheduleService } from './reschedule.service';
+import {
+  CreateReschedulePolicyDto,
+  CreateRescheduleDto,
+  RescheduleQuoteDto,
+  UpdateReschedulePolicyDto,
+} from './reschedule.dto';
+
+@ApiTags('Reschedule')
+@Controller()
+export class RescheduleController {
+  constructor(private service: RescheduleService) {}
+
+  @Get('reschedule/policies')
+  @PassengerStaff(PASSENGER_PERMS.bookings.view)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Every reschedule policy, each with its coach type (fare class)' })
+  listPolicies() {
+    return this.service.listPolicies();
+  }
+
+  @Get('reschedule/policies/available-coach-types')
+  @PassengerStaff(PASSENGER_PERMS.bookings.view)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Coach types that do not have a reschedule policy yet (add-dialog dropdown)' })
+  listUnconfiguredCoachTypes() {
+    return this.service.listUnconfiguredCoachTypes();
+  }
+
+  @Post('reschedule/policies')
+  @PassengerAdmin()
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Create a reschedule policy for a coach type (admin)' })
+  createPolicy(@Req() req: any, @Body() dto: CreateReschedulePolicyDto) {
+    return this.service.createPolicy(dto, req.user?.id);
+  }
+
+  @Patch('reschedule/policies/:coachTypeId')
+  @PassengerAdmin()
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Update the reschedule policy of a coach type (admin)' })
+  updatePolicy(@Req() req: any, @Param('coachTypeId') coachTypeId: string, @Body() dto: UpdateReschedulePolicyDto) {
+    return this.service.updatePolicy(coachTypeId, dto, req.user?.id);
+  }
+
+  @Delete('reschedule/policies/:coachTypeId')
+  @PassengerAdmin()
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Delete a reschedule policy — rescheduling is then refused for that fare class (admin)' })
+  deletePolicy(@Req() req: any, @Param('coachTypeId') coachTypeId: string) {
+    return this.service.deletePolicy(coachTypeId, req.user?.id);
+  }
+
+  @Get('bookings/:bookingRef/reschedule')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Reschedule eligibility per leg, pending request, history' })
+  options(@Req() req: any, @Param('bookingRef') bookingRef: string) {
+    return this.service.getOptions(bookingRef, req.user);
+  }
+
+  @Post('bookings/:bookingRef/reschedule/quote')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Itemised quote (fee, fare difference, amount due) for a proposed change' })
+  quote(@Req() req: any, @Param('bookingRef') bookingRef: string, @Body() dto: RescheduleQuoteDto) {
+    return this.service.quote(bookingRef, dto, req.user);
+  }
+
+  @Post('bookings/:bookingRef/reschedule')
+  @UseGuards(JwtGuard)
+  @ApiBearerAuth('JWT-auth')
+  @ApiOperation({ summary: 'Reschedule a leg. Applies immediately when nothing is due, otherwise returns a payment token' })
+  create(@Req() req: any, @Param('bookingRef') bookingRef: string, @Body() dto: CreateRescheduleDto) {
+    return this.service.create(bookingRef, dto, req.user);
+  }
+}
diff --git a/apps/edr-passenger-api/src/modules/reschedule/reschedule.dto.ts b/apps/edr-passenger-api/src/modules/reschedule/reschedule.dto.ts
new file mode 100644
index 000000000..479896adf
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/reschedule/reschedule.dto.ts
@@ -0,0 +1,77 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  ArrayMinSize,
+  IsArray,
+  IsBoolean,
+  IsInt,
+  IsOptional,
+  IsString,
+  Max,
+  Min,
+} from 'class-validator';
+
+export class UpdateReschedulePolicyDto {
+  @ApiPropertyOptional({ example: 30, description: '% of the leg fare charged as a change fee' })
+  @IsOptional() @Type(() => Number) @IsInt() @Min(0) @Max(100)
+  feePercent?: number;
+
+  @ApiPropertyOptional({ example: 50000, description: 'Fee floor in ETB minor units (500 ETB = 50000)' })
+  @IsOptional() @Type(() => Number) @IsInt() @Min(0)
+  feeMinMinor?: number;
+
+  @ApiPropertyOptional({ example: false })
+  @IsOptional() @IsBoolean()
+  routeChangeAllowed?: boolean;
+
+  @ApiPropertyOptional({ example: false })
+  @IsOptional() @IsBoolean()
+  sameDayAllowed?: boolean;
+
+  @ApiPropertyOptional({ example: 15, description: 'Same-day change: % of the leg fare (replaces feePercent)' })
+  @IsOptional() @Type(() => Number) @IsInt() @Min(0) @Max(100)
+  sameDayFeePercent?: number;
+
+  @ApiPropertyOptional({ example: 25000, description: 'Same-day change: fee floor in ETB minor units' })
+  @IsOptional() @Type(() => Number) @IsInt() @Min(0)
+  sameDayFeeMinMinor?: number;
+
+  @ApiPropertyOptional({ example: 120, description: 'Changes are refused this many minutes before departure' })
+  @IsOptional() @Type(() => Number) @IsInt() @Min(0)
+  cutoffMinutes?: number;
+
+  @ApiPropertyOptional({ example: true })
+  @IsOptional() @IsBoolean()
+  isActive?: boolean;
+}
+
+/** Same fields as the update DTO, plus the fare class the new policy attaches to. */
+export class CreateReschedulePolicyDto extends UpdateReschedulePolicyDto {
+  @ApiProperty({ example: 'coach-type-uuid', description: 'CoachType the policy applies to (one policy per fare class)' })
+  @IsString()
+  coachTypeId: string;
+}
+
+export class RescheduleQuoteDto {
+  @ApiPropertyOptional({ example: 1, description: '1 = outbound (default), 2 = return leg of a round trip' })
+  @IsOptional() @Type(() => Number) @IsInt() @Min(1) @Max(2)
+  leg?: number;
+
+  @ApiProperty({ example: 'schedule-uuid' })
+  @IsString() newScheduleId: string;
+
+  @ApiProperty({ example: 'station-uuid' })
+  @IsString() newOriginStationId: string;
+
+  @ApiProperty({ example: 'station-uuid' })
+  @IsString() newDestinationStationId: string;
+
+  @ApiProperty({ type: [String], description: 'One seat per seated passenger of the leg, in BookingSeat order' })
+  @IsArray() @ArrayMinSize(1) @IsString({ each: true })
+  newSeatIds: string[];
+}
+
+export class CreateRescheduleDto extends RescheduleQuoteDto {
+  @ApiProperty({ example: 'hold-uuid', description: 'SeatHold on the new schedule covering newSeatIds (POST /seats/hold)' })
+  @IsString() holdId: string;
+}
diff --git a/apps/edr-passenger-api/src/modules/reschedule/reschedule.module.ts b/apps/edr-passenger-api/src/modules/reschedule/reschedule.module.ts
new file mode 100644
index 000000000..ffb2c23bc
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/reschedule/reschedule.module.ts
@@ -0,0 +1,40 @@
+import { Injectable, Logger, Module } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
+import { OnEvent } from '@nestjs/event-emitter';
+import { AuditModule } from '../../common/audit.module';
+import { BookingsModule } from '../bookings/bookings.module';
+import { SeatsModule } from '../seats/seats.module';
+import { TicketsModule } from '../tickets/tickets.module';
+import { PaymentsModule } from '../payments/payments.module';
+import { CurrencyModule } from '../currency/currency.module';
+import { RescheduleController } from './reschedule.controller';
+import { RescheduleService, SUPPLEMENTARY_CHARGE_PAID_EVENT } from './reschedule.service';
+
+/**
+ * RescheduleService is request-scoped by transitivity (AuditService injects REQUEST), and Nest
+ * never fires @OnEvent on request-scoped providers — so the listener lives on this singleton and
+ * resolves the service per event, the same way TasksService reaches PaymentsService.
+ */
+@Injectable()
+export class RescheduleEventsListener {
+  private readonly logger = new Logger(RescheduleEventsListener.name);
+  constructor(private readonly moduleRef: ModuleRef) {}
+
+  @OnEvent(SUPPLEMENTARY_CHARGE_PAID_EVENT, { async: true })
+  async onChargePaid(payload: { chargeId: string }) {
+    try {
+      const service = await this.moduleRef.resolve(RescheduleService, undefined, { strict: false });
+      await service.applyForCharge(payload.chargeId);
+    } catch (err) {
+      this.logger.error(`Failed to apply reschedule for charge ${payload.chargeId}: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+}
+
+@Module({
+  imports: [AuditModule, BookingsModule, SeatsModule, TicketsModule, PaymentsModule, CurrencyModule],
+  controllers: [RescheduleController],
+  providers: [RescheduleService, RescheduleEventsListener],
+  exports: [RescheduleService],
+})
+export class RescheduleModule {}
diff --git a/apps/edr-passenger-api/src/modules/reschedule/reschedule.service.spec.ts b/apps/edr-passenger-api/src/modules/reschedule/reschedule.service.spec.ts
new file mode 100644
index 000000000..d9dca0157
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/reschedule/reschedule.service.spec.ts
@@ -0,0 +1,37 @@
+import { addisDay, computeRescheduleAmounts } from './reschedule.service';
+
+const standard = { feePercent: 30, feeMinMinor: 50000, sameDayFeePercent: 0, sameDayFeeMinMinor: 0 };
+const flex = { feePercent: 0, feeMinMinor: 0, sameDayFeePercent: 15, sameDayFeeMinMinor: 25000 };
+const premium = { feePercent: 0, feeMinMinor: 0, sameDayFeePercent: 0, sameDayFeeMinMinor: 0 };
+
+describe('computeRescheduleAmounts (policy §3)', () => {
+  it('Standard: 30% of fare, floored at 500 ETB, plus positive fare difference', () => {
+    // 1000 ETB fare → 30% = 300 < 500 floor
+    expect(computeRescheduleAmounts(standard, 100000, 120000, false)).toEqual({ feeMinor: 50000, fareDifferenceMinor: 20000, amountDueMinor: 70000 });
+    // 3000 ETB fare → 30% = 900 > floor
+    expect(computeRescheduleAmounts(standard, 300000, 300000, false)).toEqual({ feeMinor: 90000, fareDifferenceMinor: 0, amountDueMinor: 90000 });
+  });
+
+  it('negative fare difference is recorded but never paid out', () => {
+    expect(computeRescheduleAmounts(standard, 300000, 200000, false)).toEqual({ feeMinor: 90000, fareDifferenceMinor: -100000, amountDueMinor: 90000 });
+    expect(computeRescheduleAmounts(flex, 300000, 200000, false)).toEqual({ feeMinor: 0, fareDifferenceMinor: -100000, amountDueMinor: 0 });
+  });
+
+  it('Flex: free, fare difference only; same-day is 15% min 250 ETB', () => {
+    expect(computeRescheduleAmounts(flex, 100000, 150000, false)).toEqual({ feeMinor: 0, fareDifferenceMinor: 50000, amountDueMinor: 50000 });
+    expect(computeRescheduleAmounts(flex, 100000, 100000, true)).toEqual({ feeMinor: 25000, fareDifferenceMinor: 0, amountDueMinor: 25000 });
+    expect(computeRescheduleAmounts(flex, 400000, 400000, true)).toEqual({ feeMinor: 60000, fareDifferenceMinor: 0, amountDueMinor: 60000 });
+  });
+
+  it('Premium: always free, even same-day', () => {
+    expect(computeRescheduleAmounts(premium, 500000, 500000, true).amountDueMinor).toBe(0);
+    expect(computeRescheduleAmounts(premium, 500000, 560000, true).amountDueMinor).toBe(60000);
+  });
+});
+
+describe('addisDay', () => {
+  it('compares calendar days in Africa/Addis_Ababa (UTC+3), not UTC', () => {
+    expect(addisDay(new Date('2026-09-01T21:30:00Z'))).toBe('2026-09-02');
+    expect(addisDay(new Date('2026-09-01T20:30:00Z'))).toBe('2026-09-01');
+  });
+});
diff --git a/apps/edr-passenger-api/src/modules/reschedule/reschedule.service.ts b/apps/edr-passenger-api/src/modules/reschedule/reschedule.service.ts
new file mode 100644
index 000000000..fdf10ca0a
--- /dev/null
+++ b/apps/edr-passenger-api/src/modules/reschedule/reschedule.service.ts
@@ -0,0 +1,643 @@
+import {
+  BadRequestException,
+  ConflictException,
+  ForbiddenException,
+  Injectable,
+  Logger,
+  NotFoundException,
+} from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { Prisma } from '@prisma/client';
+import { PrismaService } from '../../common/prisma.service';
+import { AuditService } from '../../common/audit.service';
+import { AUDIT_ACTIONS, AUDIT_ENTITIES } from '../../common/audit.actions';
+import { MeLikeUser } from '../../common/passenger-permission.util';
+import { computePaymentDeadline } from '../../common/utils/payment-deadline.utils';
+import { normalizePhone, samePhone } from '../../common/utils/phone.utils';
+import { BookingsService } from '../bookings/bookings.service';
+import { SeatsService } from '../seats/seats.service';
+import { TicketsService } from '../tickets/tickets.service';
+import { PaymentsService } from '../payments/payments.service';
+import { SupplementaryChargesService } from '../payments/supplementary-charges.service';
+import { CurrencyService } from '../currency/currency.service';
+import {
+  CreateReschedulePolicyDto,
+  CreateRescheduleDto,
+  RescheduleQuoteDto,
+  UpdateReschedulePolicyDto,
+} from './reschedule.dto';
+
+export const RESCHEDULE_CHARGE_REASON = 'RESCHEDULE';
+export const SUPPLEMENTARY_CHARGE_PAID_EVENT = 'supplementary-charge.paid';
+
+/**
+ * Coaches nobody buys a seat in, so they can never carry a reschedule policy.
+ *
+ * Matched loosely on purpose: `CoachType.type` is documented as 'passenger' | 'sleeper' |
+ * 'dining' | 'baggage', but the live data holds display labels ('Dining Coach ', trailing space
+ * included). A `notIn: ['dining','baggage']` filter therefore matches nothing and offers the
+ * dining coach as a fare class. This mirrors the portal's own test (`/dining|dpc/i`,
+ * booking/seats/page.tsx) and checks `code` as well as `type`.
+ */
+const NON_FARE_COACH_TERMS = ['dining', 'dpc', 'baggage'];
+const NOT_A_FARE_CLASS = {
+  NOT: NON_FARE_COACH_TERMS.flatMap((term) => [
+    { type: { contains: term, mode: 'insensitive' as const } },
+    { code: { contains: term, mode: 'insensitive' as const } },
+  ]),
+};
+
+type PolicyNumbers = {
+  feePercent: number;
+  feeMinMinor: number;
+  sameDayFeePercent: number;
+  sameDayFeeMinMinor: number;
+};
+
+/**
+ * Pure fee arithmetic — policy §3. Negative fare differences are recorded but NOT paid out
+ * (credit/refund handling is a later step), so amountDue never goes below the fee.
+ */
+export function computeRescheduleAmounts(
+  policy: PolicyNumbers,
+  oldFareMinor: number,
+  newFareMinor: number,
+  isSameDay: boolean,
+): { feeMinor: number; fareDifferenceMinor: number; amountDueMinor: number } {
+  const pct = isSameDay ? policy.sameDayFeePercent : policy.feePercent;
+  const min = isSameDay ? policy.sameDayFeeMinMinor : policy.feeMinMinor;
+  const feeMinor = pct > 0 || min > 0 ? Math.max(Math.round((oldFareMinor * pct) / 100), min) : 0;
+  const fareDifferenceMinor = newFareMinor - oldFareMinor;
+  return { feeMinor, fareDifferenceMinor, amountDueMinor: feeMinor + Math.max(0, fareDifferenceMinor) };
+}
+
+export function addisDay(d: Date): string {
+  return d.toLocaleDateString('en-CA', { timeZone: 'Africa/Addis_Ababa' });
+}
+
+type ActingUser = MeLikeUser & { id?: string; sub?: string; phoneNumber?: string };
+
+type LegView = {
+  leg: number;
+  scheduleId: string;
+  originStationId: string | null;
+  destinationStationId: string | null;
+  departureAt: Date;
+  seats: Array<{ id: string; seatId: string; passengerName: string; fareMinor: number | null; passengerCategory: string }>;
+  coachTypeId: string;
+};
+
+// Seats are ordered by passenger name so getOptions(), quote() and create() all see the same
+// sequence — the client submits newSeatIds in that order (BookingSeat has no creation order).
+const bookingInclude: Prisma.BookingInclude = {
+  schedule: { select: { id: true, departureAt: true, arrivalAt: true, originStationId: true, destinationStationId: true } },
+  returnSchedule: { select: { id: true, departureAt: true, arrivalAt: true, originStationId: true, destinationStationId: true } },
+  seats: { include: { seat: { include: { coach: { select: { coachTypeId: true } } } } }, orderBy: [{ passengerName: 'asc' }, { id: 'asc' }] },
+};
+
+@Injectable()
+export class RescheduleService {
+  private readonly logger = new Logger(RescheduleService.name);
+
+  constructor(
+    private prisma: PrismaService,
+    private bookingsService: BookingsService,
+    private seatsService: SeatsService,
+    private ticketsService: TicketsService,
+    private paymentsService: PaymentsService,
+    private supplementaryCharges: SupplementaryChargesService,
+    private currencyService: CurrencyService,
+    private auditService: AuditService,
+    private eventEmitter: EventEmitter2,
+  ) {}
+
+  // ── Policy admin ─────────────────────────────────────────────────────────
+
+  /** The policies that exist, each carrying its fare class. A coach type with no policy is simply absent. */
+  async listPolicies() {
+    return this.prisma.reschedulePolicy.findMany({
+      include: { coachType: { select: { id: true, code: true, name: true, type: true } } },
+      orderBy: { coachType: { code: 'asc' } },
+    });
+  }
+
+  /** Fare classes still available to attach a policy to — the "add" dialog's dropdown. */
+  async listUnconfiguredCoachTypes() {
+    return this.prisma.coachType.findMany({
+      where: { ...NOT_A_FARE_CLASS, reschedulePolicy: { is: null } },
+      select: { id: true, code: true, name: true, type: true },
+      orderBy: { code: 'asc' },
+    });
+  }
+
+  async createPolicy(dto: CreateReschedulePolicyDto, actorId?: string) {
+    const { coachTypeId, ...values } = dto;
+    const coachType = await this.prisma.coachType.findUnique({ where: { id: coachTypeId } });
+    if (!coachType) throw new NotFoundException('Coach type not found');
+    if (NON_FARE_COACH_TERMS.some((t) => `${coachType.type} ${coachType.code}`.toLowerCase().includes(t))) {
+      throw new BadRequestException(`${coachType.code} is not a fare class — no seats are sold in it.`);
+    }
+    const existing = await this.prisma.reschedulePolicy.findUnique({ where: { coachTypeId } });
+    if (existing) throw new ConflictException(`${coachType.code} already has a reschedule policy — edit it instead.`);
+
+    const policy = await this.prisma.reschedulePolicy.create({ data: { coachTypeId, ...values } });
+    await this.auditService.log({
+      userId: actorId,
+      action: AUDIT_ACTIONS.CREATE,
+      entityType: AUDIT_ENTITIES.ReschedulePolicy,
+      entityId: policy.id,
+      newData: { coachTypeCode: coachType.code, ...values },
+    });
+    return policy;
+  }
+
+  async deletePolicy(coachTypeId: string, actorId?: string) {
+    const policy = await this.prisma.reschedulePolicy.findUnique({
+      where: { coachTypeId },
+      include: { coachType: { select: { code: true } } },
+    });
+    if (!policy) throw new NotFoundException('Reschedule policy not found');
+
+    await this.prisma.reschedulePolicy.delete({ where: { coachTypeId } });
+    await this.auditService.log({
+      userId: actorId,
+      action: AUDIT_ACTIONS.DELETE,
+      entityType: AUDIT_ENTITIES.ReschedulePolicy,
+      entityId: policy.id,
+      oldData: policy,
+    });
+    // Rescheduling for this fare class is now refused outright (legBlockers treats a missing
+    // policy the same as an inactive one), which is the intended effect of deleting it.
+    return { deleted: true, coachTypeId };
+  }
+
+  async updatePolicy(coachTypeId: string, dto: UpdateReschedulePolicyDto, actorId?: string) {
+    const coachType = await this.prisma.coachType.findUnique({ where: { id: coachTypeId } });
+    if (!coachType) throw new NotFoundException('Coach type not found');
+    const before = await this.prisma.reschedulePolicy.findUnique({ where: { coachTypeId } });
+    const policy = await this.prisma.reschedulePolicy.upsert({
+      where: { coachTypeId },
+      update: dto,
+      create: { coachTypeId, ...dto },
+    });
+    await this.auditService.log({
+      userId: actorId,
+      action: AUDIT_ACTIONS.UPDATE,
+      entityType: AUDIT_ENTITIES.ReschedulePolicy,
+      entityId: policy.id,
+      oldData: before ?? undefined,
+      newData: { coachTypeCode: coachType.code, ...dto },
+    });
+    return policy;
+  }
+
+  // ── Reads ────────────────────────────────────────────────────────────────
+
+  /** What the portal needs before picking a new schedule: per-leg eligibility + the rule set. */
+  async getOptions(bookingRef: string, user: ActingUser) {
+    const booking = await this.loadOwnedBooking(bookingRef, user);
+    const legs = this.legsOf(booking);
+    const out = [];
+    for (const leg of legs) {
+      const policy = await this.prisma.reschedulePolicy.findUnique({ where: { coachTypeId: leg.coachTypeId } });
+      const blockers = this.legBlockers(booking, leg, policy);
+      out.push({
+        leg: leg.leg,
+        scheduleId: leg.scheduleId,
+        originStationId: leg.originStationId,
+        destinationStationId: leg.destinationStationId,
+        departureAt: leg.departureAt,
+        coachTypeId: leg.coachTypeId,
+        seatCount: leg.seats.length,
+        passengerNames: leg.seats.map((s) => s.passengerName),
+        oldFareMinor: this.legFare(booking, leg),
+        policy: policy && {
+          feePercent: policy.feePercent,
+          feeMinMinor: policy.feeMinMinor,
+          routeChangeAllowed: policy.routeChangeAllowed,
+          sameDayAllowed: policy.sameDayAllowed,
+          sameDayFeePercent: policy.sameDayFeePercent,
+          sameDayFeeMinMinor: policy.sameDayFeeMinMinor,
+          cutoffMinutes: policy.cutoffMinutes,
+        },
+        canReschedule: blockers.length === 0,
+        blockers,
+      });
+    }
+    const reschedules = await this.prisma.bookingReschedule.findMany({
+      where: { bookingId: booking.id },
+      orderBy: { createdAt: 'desc' },
+    });
+    const pending = reschedules.find((r) => r.status === 'PENDING_PAYMENT');
+    const charge = pending?.supplementaryChargeId
+      ? await this.prisma.supplementaryCharge.findUnique({
+          where: { id: pending.supplementaryChargeId },
+          select: { paymentToken: true, status: true, expiresAt: true },
+        })
+      : null;
+    return {
+      bookingRef: booking.bookingRef,
+      bookingType: booking.bookingType,
+      legs: out,
+      pending: pending ? { ...pending, paymentToken: charge?.paymentToken ?? null } : null,
+      history: reschedules.filter((r) => r.status !== 'PENDING_PAYMENT'),
+    };
+  }
+
+  // ── Quote / create / apply ───────────────────────────────────────────────
+
+  async quote(bookingRef: string, dto: RescheduleQuoteDto, user: ActingUser) {
+    const booking = await this.loadOwnedBooking(bookingRef, user);
+    return this.buildQuote(booking, dto);
+  }
+
+  async create(bookingRef: string, dto: CreateRescheduleDto, user: ActingUser) {
+    const booking = await this.loadOwnedBooking(bookingRef, user);
+    const q = await this.buildQuote(booking, dto);
+    if (!q.allowed) throw new BadRequestException(q.blockers.join(' '));
+
+    const hold = await this.prisma.seatHold.findUnique({ where: { id: dto.holdId } });
+    if (!hold || hold.expiresAt < new Date()) throw new BadRequestException('Seat hold expired');
+    if (hold.scheduleId !== dto.newScheduleId) throw new BadRequestException('Seat hold is for a different schedule');
+    const held = new Set(hold.seatIds);
+    if (!dto.newSeatIds.every((id) => held.has(id))) throw new BadRequestException('Selected seats are not covered by the hold');
+
+    // Availability was enforced when the hold was taken (holdSeats checks holds + booked
+    // segments for the leg); tickets.generate() re-checks at apply time.
+
+    const requestedBy = user.id ?? user.sub ?? booking.passengerId;
+    const newDeparture = q.newDepartureAt;
+    const expiresAt = computePaymentDeadline(new Date(), newDeparture);
+
+    const reschedule = await this.prisma.bookingReschedule.create({
+      data: {
+        bookingId: booking.id,
+        leg: q.leg,
+        status: 'PENDING_PAYMENT',
+        requestedBy,
+        oldScheduleId: q.oldScheduleId,
+        newScheduleId: dto.newScheduleId,
+        oldOriginStationId: q.oldOriginStationId,
+        oldDestinationStationId: q.oldDestinationStationId,
+        newOriginStationId: dto.newOriginStationId,
+        newDestinationStationId: dto.newDestinationStationId,
+        oldSeatIds: q.oldSeatIds,
+        newSeatIds: dto.newSeatIds,
+        holdId: dto.holdId,
+        oldFareMinor: q.oldFareMinor,
+        newFareMinor: q.newFareMinor,
+        fareDifferenceMinor: q.fareDifferenceMinor,
+        feeMinor: q.feeMinor,
+        amountDueMinor: q.amountDueMinor,
+        isSameDay: q.isSameDay,
+        isRouteChange: q.isRouteChange,
+        expiresAt: q.amountDueMinor > 0 ? expiresAt : null,
+      },
+    });
+
+    if (q.amountDueMinor === 0) {
+      await this.apply(reschedule.id);
+      return { rescheduleId: reschedule.id, status: 'APPLIED', amountDueMinor: 0, paymentToken: null, quote: q };
+    }
+
+    // Money owed: raise a supplementary charge (pay page /pay-balance/:token, SMS+email link) and
+    // keep the new seats held until the same deadline the charge carries.
+    const charge = await this.supplementaryCharges.create({
+      bookingRef: booking.bookingRef,
+      amountMinor: q.amountDueMinor,
+      reason: RESCHEDULE_CHARGE_REASON,
+      notes: `Reschedule leg ${q.leg} → schedule ${dto.newScheduleId}`,
+      createdBy: requestedBy,
+      expiresAt,
+    });
+    await this.prisma.bookingReschedule.update({
+      where: { id: reschedule.id },
+      data: { supplementaryChargeId: charge.id },
+    });
+    await this.seatsService.confirmSeats(dto.newSeatIds);
+
+    await this.auditService.log({
+      userId: requestedBy,
+      action: AUDIT_ACTIONS.CREATE,
+      entityType: AUDIT_ENTITIES.BookingReschedule,
+      entityId: reschedule.id,
+      newData: { bookingRef: booking.bookingRef, leg: q.leg, amountDueMinor: q.amountDueMinor, chargeId: charge.id },
+    });
+    return { rescheduleId: reschedule.id, status: 'PENDING_PAYMENT', amountDueMinor: q.amountDueMinor, paymentToken: charge.paymentToken, expiresAt, quote: q };
+  }
+
+  /** Entry point for the paid-charge event. Idempotent: only a PENDING_PAYMENT row is applied. */
+  async applyForCharge(supplementaryChargeId: string) {
+    const r = await this.prisma.bookingReschedule.findUnique({ where: { supplementaryChargeId } });
+    if (!r || r.status !== 'PENDING_PAYMENT') return;
+    await this.apply(r.id);
+  }
+
+  /** Moves the booking leg: booking fields, seats, journey segments, tickets. */
+  async apply(rescheduleId: string) {
+    const r = await this.prisma.bookingReschedule.findUnique({ where: { id: rescheduleId } });
+    if (!r) throw new NotFoundException('Reschedule not found');
+    if (r.status !== 'PENDING_PAYMENT') return r;
+
+    const booking = await this.prisma.booking.findUnique({ where: { id: r.bookingId }, include: bookingInclude });
+    if (!booking) throw new NotFoundException('Booking not found');
+    const leg = this.legsOf(booking).find((l) => l.leg === r.leg);
+    if (!leg) throw new BadRequestException('Leg no longer exists on booking');
+    if (leg.seats.length !== r.newSeatIds.length) throw new BadRequestException('Seat count changed since quote');
+
+    const newTotal = Math.max(0, booking.totalMinor + r.fareDifferenceMinor);
+    const displayTotal =
+      booking.displayCurrency && booking.displayCurrency !== 'ETB'
+        ? await this.currencyService.convertAmount(newTotal, 'ETB' as any, booking.displayCurrency as any)
+        : newTotal;
+    const perSeatNew = this.splitFare(r.newFareMinor, leg.seats);
+
+    await this.prisma.$transaction(async (tx) => {
+      await tx.booking.update({
+        where: { id: booking.id },
+        data: {
+          ...(r.leg === 1
+            ? { scheduleId: r.newScheduleId, originStationId: r.newOriginStationId, destinationStationId: r.newDestinationStationId }
+            : { returnScheduleId: r.newScheduleId, returnOriginStationId: r.newOriginStationId, returnDestinationStationId: r.newDestinationStationId }),
+          totalMinor: newTotal,
+          displayTotalMinor: displayTotal,
+        },
+      });
+      // Two passes so the (scheduleId, seatId) unique key never collides mid-update when a
+      // passenger takes a seat another passenger of the same booking is leaving.
+      for (const s of leg.seats) {
+        await tx.bookingSeat.update({ where: { id: s.id }, data: { scheduleId: `moving-${s.id}` } });
+      }
+      for (let i = 0; i < leg.seats.length; i++) {
+        await tx.bookingSeat.update({
+          where: { id: leg.seats[i].id },
+          data: { seatId: r.newSeatIds[i], scheduleId: r.newScheduleId, fareMinor: perSeatNew[i], seatLabelSnapshot: null },
+        });
+      }
+      await tx.bookingModification.create({
+        data: {
+          bookingId: booking.id,
+          modifiedBy: r.requestedBy,
+          modificationType: 'RESCHEDULE',
+          oldData: { leg: r.leg, scheduleId: r.oldScheduleId, originStationId: r.oldOriginStationId, destinationStationId: r.oldDestinationStationId, seatIds: r.oldSeatIds, fareMinor: r.oldFareMinor },
+          newData: { leg: r.leg, scheduleId: r.newScheduleId, originStationId: r.newOriginStationId, destinationStationId: r.newDestinationStationId, seatIds: r.newSeatIds, fareMinor: r.newFareMinor, feeMinor: r.feeMinor },
+          fareAdjustment: r.fareDifferenceMinor,
+        },
+      });
+      await tx.bookingReschedule.update({ where: { id: r.id }, data: { status: 'APPLIED', appliedAt: new Date() } });
+    });
+
+    // Occupancy + tickets are rebuilt from the (now updated) booking, outside the transaction.
+    const fresh = await this.prisma.booking.findUnique({ where: { id: booking.id }, include: { seats: true, tickets: { select: { id: true } } } });
+    if (fresh) {
+      try {
+        await this.seatsService.releaseSeats(fresh.id);
+        await this.paymentsService.createJourneySegments(fresh as any);
+      } catch (err) {
+        this.logger.error(`Reschedule ${r.id}: journey segments failed: ${err instanceof Error ? err.message : err}`);
+      }
+      // Old tickets' SYSTEM seat blocks reference ticket ids that generate() is about to delete.
+      for (const t of fresh.tickets) {
+        await this.prisma.seatBlock.deleteMany({ where: { reason: { contains: t.id }, blockedBy: 'SYSTEM' } });
+      }
+      try { await this.ticketsService.generate(fresh.id); } catch (err) {
+        this.logger.error(`Reschedule ${r.id}: ticket generation failed: ${err instanceof Error ? err.message : err}`);
+      }
+    }
+    // The new seats are owned by the journey now; the old seats' own booking-time hold (holds
+    // outlive confirmation until the payment deadline) would otherwise keep them HELD on the old
+    // schedule. Nobody else can hold a booked seat, so any hold there is this booking's.
+    await this.prisma.seatHold.deleteMany({
+      where: { OR: [{ id: r.holdId ?? '' }, { scheduleId: r.oldScheduleId, seatIds: { hasSome: r.oldSeatIds } }] },
+    });
+
+    await this.auditService.log({
+      userId: r.requestedBy,
+      action: AUDIT_ACTIONS.UPDATE,
+      entityType: AUDIT_ENTITIES.Booking,
+      entityId: booking.id,
+      oldData: { leg: r.leg, scheduleId: r.oldScheduleId, seatIds: r.oldSeatIds },
+      newData: { leg: r.leg, scheduleId: r.newScheduleId, seatIds: r.newSeatIds, feeMinor: r.feeMinor, fareDifferenceMinor: r.fareDifferenceMinor, rescheduleId: r.id },
+    });
+    this.eventEmitter.emit('booking.rescheduled', { booking: fresh ?? booking, reschedule: r });
+    return { ...r, status: 'APPLIED' };
+  }
+
+  /** Cron hook: unpaid reschedules past their payment deadline. The seat hold lapses by itself. */
+  async expireStale(now = new Date()): Promise<number> {
+    const stale = await this.prisma.bookingReschedule.findMany({
+      where: { status: 'PENDING_PAYMENT', expiresAt: { lt: now } },
+      select: { id: true, supplementaryChargeId: true },
+    });
+    for (const r of stale) {
+      await this.prisma.bookingReschedule.update({ where: { id: r.id }, data: { status: 'EXPIRED' } });
+      if (r.supplementaryChargeId) {
+        await this.prisma.supplementaryCharge.updateMany({
+          where: { id: r.supplementaryChargeId, status: 'PENDING' },
+          data: { status: 'EXPIRED' },
+        });
+      }
+    }
+    return stale.length;
+  }
+
+  // ── Internals ────────────────────────────────────────────────────────────
+
+  /**
+   * Who may act on this booking: only the person who made it, proven by their account's phone
+   * number matching the booking's `contactPhone`. Being merely *named* on the booking is not
+   * enough — a passenger travelling on someone else's booking cannot move it.
+   *
+   * There is deliberately no staff override. The `bookings:reschedule` permission still exists in
+   * the registry (and on the stationMaster preset) but is not honoured here, so a station master
+   * cannot reschedule on a customer's behalf yet. To restore it, re-import
+   * `hasPassengerPermission` / `PASSENGER_PERMS` and return the booking early when the caller
+   * holds `PASSENGER_PERMS.bookings.reschedule`.
+   */
+  private async loadOwnedBooking(bookingRef: string, user: ActingUser) {
+    const booking = await this.prisma.booking.findUnique({ where: { bookingRef }, include: bookingInclude });
+    if (!booking) throw new NotFoundException('Booking not found');
+    const iamUserId = user.id ?? user.sub;
+    if (!iamUserId) throw new ForbiddenException();
+
+    if (booking.contactPhone) {
+      const callerPhone = await this.resolveUserPhone(iamUserId, user);
+      if (samePhone(callerPhone, booking.contactPhone)) return booking;
+      throw new ForbiddenException(
+        'Only the person who made this booking can reschedule it. Sign in with the phone number used to book.',
+      );
+    }
+
+    // ~0.3% of bookings (72 of 24.7k on dev) carry no contactPhone at all, so there is nothing to
+    // match against. Fall back to the account link rather than locking their owner out entirely.
+    const passenger = await this.prisma.passenger.findUnique({ where: { iamUserId }, select: { id: true } });
+    if (!passenger || passenger.id !== booking.passengerId) throw new ForbiddenException('Not your booking');
+    return booking;
+  }
+
+  /**
+   * The signed-in user's phone. The session snapshot (`userInfo.phoneNumber`) is frequently an
+   * empty string, so `iam.users` is the source of truth — and reading it live also means a user
+   * who changed their number does not have to sign out before the new one counts.
+   */
+  private async resolveUserPhone(iamUserId: string, user: ActingUser): Promise<string | null> {
+    const fromSession = normalizePhone(user.phoneNumber);
+    if (fromSession) return fromSession;
+    const rows = await this.prisma.$queryRaw<{ phone_number: string | null }[]>`
+      SELECT phone_number FROM iam.users WHERE id = ${iamUserId}::uuid LIMIT 1
+    `;
+    return normalizePhone(rows[0]?.phone_number);
+  }
+
+  private legsOf(booking: any): LegView[] {
+    const legs: LegView[] = [];
+    const seatsOf = (n: number) =>
+      (booking.seats as any[])
+        .filter((s) => (s.leg ?? 1) === n)
+        .map((s) => ({ id: s.id, seatId: s.seatId, passengerName: s.passengerName, fareMinor: s.fareMinor, passengerCategory: s.passengerCategory, coachTypeId: s.seat?.coach?.coachTypeId }));
+    const l1 = seatsOf(1);
+    if (l1.length && booking.schedule) {
+      legs.push({ leg: 1, scheduleId: booking.scheduleId, originStationId: booking.originStationId, destinationStationId: booking.destinationStationId, departureAt: booking.schedule.departureAt, seats: l1, coachTypeId: l1[0].coachTypeId });
+    }
+    const l2 = seatsOf(2);
+    if (booking.bookingType === 'ROUND_TRIP' && l2.length && booking.returnSchedule) {
+      legs.push({ leg: 2, scheduleId: booking.returnScheduleId, originStationId: booking.returnOriginStationId, destinationStationId: booking.returnDestinationStationId, departureAt: booking.returnSchedule.departureAt, seats: l2, coachTypeId: l2[0].coachTypeId });
+    }
+    return legs;
+  }
+
+  /** The leg's original fare: per-seat amounts when recorded, else the whole booking (one-way). */
+  private legFare(booking: any, leg: LegView): number {
+    const recorded = leg.seats.reduce((sum, s) => sum + (s.fareMinor ?? 0), 0);
+    if (recorded > 0) return recorded;
+    return booking.bookingType === 'ONE_WAY' ? booking.totalMinor : Math.round(booking.totalMinor / 2);
+  }
+
+  private legBlockers(booking: any, leg: LegView, policy: any, now = new Date()): string[] {
+    const blockers: string[] = [];
+    if (!['ONE_WAY', 'ROUND_TRIP'].includes(booking.bookingType)) blockers.push('Only one-way and round-trip bookings can be rescheduled.');
+    if (booking.status !== 'CONFIRMED') blockers.push('Only confirmed bookings can be rescheduled.');
+    // ponytail: a boarded leg can't be moved and tickets.generate() rebuilds every leg, so a
+    // round trip whose outbound was already used can't change its return yet — needs leg-scoped
+    // ticket regeneration.
+    if (booking.outboundBoardedAt || booking.returnBoardedAt) blockers.push('This booking has already been used for travel.');
+    if (!policy || !policy.isActive) blockers.push('Rescheduling is not available for this fare class.');
+    else if (leg.departureAt.getTime() - now.getTime() < policy.cutoffMinutes * 60_000) {
+      blockers.push(`Changes must be made at least ${policy.cutoffMinutes} minutes before departure.`);
+    }
+    return blockers;
+  }
+
+  private async buildQuote(booking: any, dto: RescheduleQuoteDto) {
+    const legNo = dto.leg ?? 1;
+    const leg = this.legsOf(booking).find((l) => l.leg === legNo);
+    if (!leg) throw new BadRequestException(`Booking has no leg ${legNo}`);
+    const policy = await this.prisma.reschedulePolicy.findUnique({ where: { coachTypeId: leg.coachTypeId } });
+    const blockers = this.legBlockers(booking, leg, policy);
+
+    const pending = await this.prisma.bookingReschedule.findFirst({ where: { bookingId: booking.id, status: 'PENDING_PAYMENT' } });
+    if (pending) blockers.push('A reschedule is already awaiting payment for this booking.');
+    if (dto.newSeatIds.length !== leg.seats.length) blockers.push(`Select exactly ${leg.seats.length} seat(s).`);
+    if (new Set(dto.newSeatIds).size !== dto.newSeatIds.length) blockers.push('Duplicate seats selected.');
+
+    const schedule = await this.prisma.trainSchedule.findUnique({
+      where: { id: dto.newScheduleId },
+      include: { stopTimes: { include: { station: true }, orderBy: { sequence: 'asc' } } },
+    });
+    if (!schedule) throw new NotFoundException('New schedule not found');
+    const now = new Date();
+    if (schedule.departureAt <= now || schedule.status !== 'SCHEDULED') blockers.push('The selected departure is no longer bookable.');
+    if (schedule.id === leg.scheduleId && dto.newOriginStationId === leg.originStationId && dto.newDestinationStationId === leg.destinationStationId) {
+      blockers.push('Pick a different departure, route or date.');
+    }
+    const originStop = schedule.stopTimes.find((s) => s.stationId === dto.newOriginStationId);
+    const destStop = schedule.stopTimes.find((s) => s.stationId === dto.newDestinationStationId);
+    if (!originStop || !destStop || originStop.sequence >= destStop.sequence) blockers.push('Origin/destination are not valid for this schedule.');
+
+    const isRouteChange = dto.newOriginStationId !== leg.originStationId || dto.newDestinationStationId !== leg.destinationStationId;
+    if (isRouteChange && policy && !policy.routeChangeAllowed) blockers.push('Route changes are not permitted for this fare class.');
+    const isSameDay = addisDay(schedule.departureAt) === addisDay(leg.departureAt);
+    if (isSameDay && policy && !policy.sameDayAllowed) blockers.push('Same-day changes are not permitted for this fare class.');
+
+    // Keep the round trip chronologically sane.
+    if (booking.bookingType === 'ROUND_TRIP') {
+      if (legNo === 1 && booking.returnSchedule && schedule.arrivalAt >= booking.returnSchedule.departureAt) blockers.push('New outbound must arrive before the return departs.');
+      if (legNo === 2 && booking.schedule && schedule.departureAt <= booking.schedule.arrivalAt) blockers.push('New return must depart after the outbound arrives.');
+    }
+
+    // New seats: same coach type as booked (no class change in this step), priced per seat.
+    const seats = await this.prisma.seat.findMany({
+      where: { id: { in: dto.newSeatIds } },
+      include: { coach: { include: { coachType: { include: { seatClasses: { where: { isActive: true } } } } } } },
+    });
+    const seatById = new Map(seats.map((s) => [s.id, s]));
+    let newFareMinor = 0;
+    if (originStop && destStop && seats.length === dto.newSeatIds.length) {
+      const nationalityType = booking.displayCurrency === 'USD' ? 'INTERNATIONAL' : 'LOCAL';
+      // ponytail: passenger nationality isn't stored on the booking; currency is the proxy the
+      // search/fare code already uses (ETB/DJF = local, USD = international).
+      const nationality = booking.displayCurrency === 'DJF' ? 'Djiboutian' : booking.displayCurrency === 'ETB' ? 'Ethiopian' : undefined;
+      const segmentRoute = `${originStop.station.code}-${destStop.station.code}`;
+      for (let i = 0; i < dto.newSeatIds.length; i++) {
+        const seat = seatById.get(dto.newSeatIds[i])!;
+        if (seat.coach.coachTypeId !== leg.coachTypeId) { blockers.push('New seats must be in the same class as the original booking.'); break; }
+        const oldSeat = leg.seats[i];
+        if (oldSeat.fareMinor === 0) continue; // free child keeps riding free
+        const seatClass = this.pickSeatClass(seat.coach.coachType.seatClasses, seat.bedPosition, nationalityType);
+        if (!seatClass) { blockers.push('No fare is configured for the selected seat.'); break; }
+        newFareMinor += await this.bookingsService.getBaseFare(
+          schedule.id, seatClass.id, segmentRoute, undefined, nationality,
+          originStop.sequence, destStop.sequence, originStop.stationId, destStop.stationId,
+        );
+      }
+    } else if (seats.length !== dto.newSeatIds.length) {
+      blockers.push('One or more selected seats do not exist.');
+    }
+
+    const oldFareMinor = this.legFare(booking, leg);
+    const amounts = policy
+      ? computeRescheduleAmounts(policy, oldFareMinor, newFareMinor, isSameDay)
+      : { feeMinor: 0, fareDifferenceMinor: newFareMinor - oldFareMinor, amountDueMinor: 0 };
+
+    return {
+      allowed: blockers.length === 0,
+      blockers: Array.from(new Set(blockers)),
+      leg: legNo,
+      oldScheduleId: leg.scheduleId,
+      oldOriginStationId: leg.originStationId,
+      oldDestinationStationId: leg.destinationStationId,
+      oldSeatIds: leg.seats.map((s) => s.seatId),
+      newScheduleId: schedule.id,
+      newDepartureAt: schedule.departureAt,
+      isSameDay,
+      isRouteChange,
+      oldFareMinor,
+      newFareMinor,
+      ...amounts,
+      currency: 'ETB',
+      cutoffAt: policy ? new Date(leg.departureAt.getTime() - policy.cutoffMinutes * 60_000) : null,
+      policy: policy && { feePercent: policy.feePercent, feeMinMinor: policy.feeMinMinor, sameDayFeePercent: policy.sameDayFeePercent, sameDayFeeMinMinor: policy.sameDayFeeMinMinor, routeChangeAllowed: policy.routeChangeAllowed, sameDayAllowed: policy.sameDayAllowed, cutoffMinutes: policy.cutoffMinutes },
+    };
+  }
+
+  /** Mirrors SearchService's class matching: nationality filter, then bed position. */
+  private pickSeatClass(classes: any[], bedPosition: string | null, nationalityType: string) {
+    const byNat = classes.filter((c) => !c.nationalityType || c.nationalityType === nationalityType);
+    const pool = byNat.length ? byNat : classes;
+    const bed = bedPosition?.toLowerCase() ?? null;
+    const exact = pool.find((c) => (c.bedPosition?.toLowerCase() ?? null) === bed);
+    return exact ?? pool.find((c) => !c.bedPosition) ?? pool[0] ?? null;
+  }
+
+  /** Distributes the leg fare over seats, free children (fare 0) stay 0; rounding lands on the last paid seat. */
+  private splitFare(total: number, seats: LegView['seats']): number[] {
+    const paid = seats.map((s) => s.fareMinor !== 0);
+    const n = paid.filter(Boolean).length || 1;
+    const each = Math.floor(total / n);
+    let remaining = total;
+    let lastPaid = -1;
+    const out = seats.map((_, i) => { if (!paid[i]) return 0; lastPaid = i; remaining -= each; return each; });
+    if (lastPaid >= 0) out[lastPaid] += remaining;
+    return out;
+  }
+}
diff --git a/apps/edr-passenger-api/src/modules/seats/seats.service.ts b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
index f39da4e80..c678dcf44 100644
--- a/apps/edr-passenger-api/src/modules/seats/seats.service.ts
+++ b/apps/edr-passenger-api/src/modules/seats/seats.service.ts
@@ -739,9 +739,11 @@ export class SeatsService {
     }
   }
 
-  // Delete the Journey (and its JourneySegments) scoped to this booking.
+  // Delete the Journey (and its JourneySegments) scoped to this booking. The segment FK has no
+  // ON DELETE CASCADE, so segments go first or the journey delete fails on a ticketed booking.
   async releaseSeats(bookingId: string) {
-    await this.prisma.journey.deleteMany({ where: { bookingId } as any });
+    await this.prisma.journeySegment.deleteMany({ where: { journey: { bookingId } } });
+    await this.prisma.journey.deleteMany({ where: { bookingId } });
   }
 
   async getBlockedSeats() {
diff --git a/apps/edr-passenger-api/src/modules/tasks/tasks.service.ts b/apps/edr-passenger-api/src/modules/tasks/tasks.service.ts
index fe4207a50..27a94f4e9 100644
--- a/apps/edr-passenger-api/src/modules/tasks/tasks.service.ts
+++ b/apps/edr-passenger-api/src/modules/tasks/tasks.service.ts
@@ -5,6 +5,7 @@ import { PrismaService } from '../../common/prisma.service';
 import { SmsClientService } from '../notifications/sms-client.service';
 import { CurrencyService } from '../currency/currency.service';
 import { PaymentsService } from '../payments/payments.service';
+import { RescheduleService } from '../reschedule/reschedule.service';
 import { MAX_PAYMENT_HOURS, CUTOFF_MINUTES, computePaymentDeadline } from '../../common/utils/payment-deadline.utils';
 
 // Retention windows
@@ -510,6 +511,21 @@ export class TasksService {
   // ─────────────────────────────────────────────────────────────────────────
   // Daily at 02:00 EAT: purge expired/stale records to enforce data retention.
   // ─────────────────────────────────────────────────────────────────────────
+  // ─────────────────────────────────────────────────────────────────────────
+  // Every 1 min: reschedule requests whose payment deadline passed → EXPIRED
+  // (their supplementary charge too). The new-seat hold lapses on its own.
+  // ─────────────────────────────────────────────────────────────────────────
+  @Cron('*/1 * * * *')
+  async expireStaleReschedules() {
+    try {
+      const reschedule = await this.moduleRef.resolve(RescheduleService, undefined, { strict: false });
+      const n = await reschedule.expireStale();
+      if (n > 0) this.logger.log(`Expired ${n} unpaid reschedule request(s)`);
+    } catch (err) {
+      this.logger.error(`expireStaleReschedules failed: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
   @Cron('0 2 * * *')
   async purgeExpiredData() {
     const now = new Date();
diff --git a/apps/edr-passenger-api/src/seed/passenger-permissions.registry.ts b/apps/edr-passenger-api/src/seed/passenger-permissions.registry.ts
index 82cc62ef6..d30f37d94 100644
--- a/apps/edr-passenger-api/src/seed/passenger-permissions.registry.ts
+++ b/apps/edr-passenger-api/src/seed/passenger-permissions.registry.ts
@@ -18,6 +18,7 @@ export const PASSENGER_PERMISSIONS: PassengerPermissionSeed[] = [
   perm('40f1b49c-c33d-4563-a6bb-9373eabbde9b', 'edr_passenger_app:bookings:view',              'View bookings'),
   perm('62810ae5-315e-4ae5-8ed1-33cead51b95a', 'edr_passenger_app:bookings:manage',            'Manage bookings'),
   perm('b593adf3-2060-48b0-b35d-ff9ff5d72bc4', 'edr_passenger_app:bookings:cancel',            'Cancel bookings'),
+  perm('0c5e7a2b-9d41-4f7e-8b36-2a1c6d9e4f50', 'edr_passenger_app:bookings:reschedule',        'Reschedule bookings'),
   perm('566c968f-71f1-462d-9824-4b7cd33cecbb', 'edr_passenger_app:passengers:view',            'View passengers'),
   perm('ff5d33a0-0fe7-427f-a065-46dd14ac1da0', 'edr_passenger_app:passengers:manage',          'Manage passengers'),
   perm('326ec767-1da8-4c7e-b557-d4d2f9dd6d2c', 'edr_passenger_app:tickets:view',               'View tickets'),
@@ -77,6 +78,7 @@ export const PASSENGER_PERMS = {
     view:   'edr_passenger_app:bookings:view',
     manage: 'edr_passenger_app:bookings:manage',
     cancel: 'edr_passenger_app:bookings:cancel',
+    reschedule: 'edr_passenger_app:bookings:reschedule',
   },
   passengers: {
     view:   'edr_passenger_app:passengers:view',
@@ -181,6 +183,7 @@ export const ROLE_PERMISSION_PRESETS = {
   stationMaster: [
     PASSENGER_PERMS.bookings.view,
     PASSENGER_PERMS.bookings.manage,
+    PASSENGER_PERMS.bookings.reschedule,
     PASSENGER_PERMS.tickets.view,
     PASSENGER_PERMS.tickets.manage,
     PASSENGER_PERMS.tickets.generate,
diff --git a/apps/edr-passenger-web/backoffice/src/app/reschedule-policies/layout.tsx b/apps/edr-passenger-web/backoffice/src/app/reschedule-policies/layout.tsx
new file mode 100644
index 000000000..8e7a60fce
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/reschedule-policies/layout.tsx
@@ -0,0 +1,5 @@
+import DashboardLayout from '../dashboard/layout';
+
+export default function ReschedulePoliciesLayout({ children }: { children: React.ReactNode }) {
+  return <DashboardLayout>{children}</DashboardLayout>;
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/reschedule-policies/page.tsx b/apps/edr-passenger-web/backoffice/src/app/reschedule-policies/page.tsx
new file mode 100644
index 000000000..31f265b6c
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/app/reschedule-policies/page.tsx
@@ -0,0 +1,26 @@
+'use client';
+
+import ReschedulePolicyManager from '@/components/reschedule/ReschedulePolicyManager';
+import { PermissionGuard } from '@/components/layout/PermissionGuard';
+import { PERMS } from '@/lib/permissions';
+
+/**
+ * Master Data → Reschedule Policies. One policy per fare class (coach type); a class with no
+ * policy cannot be rescheduled at all. Gated on bookings:view because that is what
+ * `GET /reschedule/policies` requires; creating, editing and deleting are admin-only server-side.
+ */
+export default function ReschedulePoliciesPage() {
+  return (
+    <PermissionGuard permission={PERMS.bookings.view}>
+      <div className="space-y-6">
+        <div>
+          <h1 className="text-3xl font-bold text-foreground">Reschedule Policies</h1>
+          <p className="text-muted-foreground mt-1">
+            Rules that decide whether a booked journey can be moved, and what the change costs
+          </p>
+        </div>
+        <ReschedulePolicyManager />
+      </div>
+    </PermissionGuard>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/app/settings/page.tsx b/apps/edr-passenger-web/backoffice/src/app/settings/page.tsx
index 873e81578..90725b683 100644
--- a/apps/edr-passenger-web/backoffice/src/app/settings/page.tsx
+++ b/apps/edr-passenger-web/backoffice/src/app/settings/page.tsx
@@ -111,6 +111,7 @@ export default function SettingsPage() {
         </div>
       )}
       
+
       {activeTab === 'configurations' && (
         <div className="card space-y-6">
           <h3 className="text-lg font-semibold text-foreground">Rate Limiting (requests / minute / IP)</h3>
diff --git a/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
index 909361c46..99c24be9a 100644
--- a/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
+++ b/apps/edr-passenger-web/backoffice/src/components/layout/Sidebar.tsx
@@ -28,6 +28,7 @@ import {
   FileText,
   Briefcase,
   Calendar,
+  CalendarClock,
   Utensils,
   Package,
   Moon,
@@ -90,6 +91,7 @@ const navigationSections: { title: string; items: NavItem[] }[] = [
       { name: 'Classes',    href: '/classes',    icon: Settings, permission: PERMS.classes.view },
       { name: 'Routes',     href: '/routes',     icon: Route,    permission: PERMS.routes.view },
       { name: 'Schedules',  href: '/schedules',  icon: Calendar, permission: PERMS.schedules.view },
+      { name: 'Reschedule Policies', href: '/reschedule-policies', icon: CalendarClock, permission: PERMS.bookings.view },
     ]
   },
   {
diff --git a/apps/edr-passenger-web/backoffice/src/components/reschedule/ReschedulePolicyManager.tsx b/apps/edr-passenger-web/backoffice/src/components/reschedule/ReschedulePolicyManager.tsx
new file mode 100644
index 000000000..efc1ca5d2
--- /dev/null
+++ b/apps/edr-passenger-web/backoffice/src/components/reschedule/ReschedulePolicyManager.tsx
@@ -0,0 +1,376 @@
+'use client';
+
+import { useEffect, useState } from 'react';
+import { Edit, Plus, Save, Trash2 } from 'lucide-react';
+import DataTable from '@/components/ui/DataTable';
+import ActionButton from '@/components/ui/ActionButton';
+import Modal from '@/components/ui/Modal';
+import ConfirmDialog from '@/components/ui/ConfirmDialog';
+import {
+  reschedulePolicyApi,
+  type ReschedulePolicyCoachType,
+  type ReschedulePolicyRow,
+  type ReschedulePolicyValues,
+} from '@/lib/api';
+
+const EMPTY_POLICY: ReschedulePolicyValues = {
+  feePercent: 0,
+  feeMinMinor: 0,
+  routeChangeAllowed: true,
+  sameDayAllowed: true,
+  sameDayFeePercent: 0,
+  sameDayFeeMinMinor: 0,
+  cutoffMinutes: 60,
+  isActive: true,
+};
+
+// Money is entered in ETB and stored in minor units.
+const etb = (minor: number) => String(minor / 100);
+const toMinor = (value: string) => Math.round(Number(value || 0) * 100);
+const feeLabel = (percent: number, minMinor: number) =>
+  percent > 0 || minMinor > 0 ? `${percent}% · min ETB ${etb(minMinor)}` : 'Free';
+
+/**
+ * Policy §3  -  one policy per fare class (coach type), listed as a table and edited in a dialog,
+ * the same shape as Coach Management. A fare class with no row here cannot be rescheduled at all.
+ */
+export default function ReschedulePolicyManager() {
+  const [rows, setRows] = useState<ReschedulePolicyRow[]>([]);
+  const [available, setAvailable] = useState<ReschedulePolicyCoachType[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [message, setMessage] = useState('');
+
+  const [showModal, setShowModal] = useState(false);
+  const [editing, setEditing] = useState<ReschedulePolicyRow | null>(null);
+  const [coachTypeId, setCoachTypeId] = useState('');
+  const [form, setForm] = useState<ReschedulePolicyValues>(EMPTY_POLICY);
+  const [saving, setSaving] = useState(false);
+  const [formError, setFormError] = useState('');
+
+  const [deleting, setDeleting] = useState<ReschedulePolicyRow | null>(null);
+  const [deleteBusy, setDeleteBusy] = useState(false);
+
+  const load = async () => {
+    setLoading(true);
+    try {
+      const [policies, coachTypes] = await Promise.all([
+        reschedulePolicyApi.list(),
+        reschedulePolicyApi.availableCoachTypes(),
+      ]);
+      setRows(Array.isArray(policies) ? policies : []);
+      setAvailable(Array.isArray(coachTypes) ? coachTypes : []);
+    } catch {
+      setMessage('Failed to load reschedule policies.');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    void load();
+  }, []);
+
+  const openCreate = () => {
+    setEditing(null);
+    setCoachTypeId('');
+    setForm(EMPTY_POLICY);
+    setFormError('');
+    setShowModal(true);
+  };
+
+  const openEdit = (row: ReschedulePolicyRow) => {
+    setEditing(row);
+    setCoachTypeId(row.coachTypeId);
+    setForm({
+      feePercent: row.feePercent,
+      feeMinMinor: row.feeMinMinor,
+      routeChangeAllowed: row.routeChangeAllowed,
+      sameDayAllowed: row.sameDayAllowed,
+      sameDayFeePercent: row.sameDayFeePercent,
+      sameDayFeeMinMinor: row.sameDayFeeMinMinor,
+      cutoffMinutes: row.cutoffMinutes,
+      isActive: row.isActive,
+    });
+    setFormError('');
+    setShowModal(true);
+  };
+
+  const setField = (patch: Partial<ReschedulePolicyValues>) => setForm((f) => ({ ...f, ...patch }));
+
+  const submit = async () => {
+    if (!editing && !coachTypeId) {
+      setFormError('Pick a fare class.');
+      return;
+    }
+    setSaving(true);
+    setFormError('');
+    try {
+      if (editing) await reschedulePolicyApi.update(editing.coachTypeId, form);
+      else await reschedulePolicyApi.create({ coachTypeId, ...form });
+      setShowModal(false);
+      setMessage(editing ? 'Policy updated.' : 'Policy created.');
+      await load();
+    } catch (err: any) {
+      setFormError(err?.response?.data?.message || err?.message || 'Failed to save the policy.');
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const confirmDelete = async () => {
+    if (!deleting) return;
+    setDeleteBusy(true);
+    try {
+      await reschedulePolicyApi.remove(deleting.coachTypeId);
+      setDeleting(null);
+      setMessage('Policy deleted.');
+      await load();
+    } catch {
+      setMessage('Failed to delete the policy.');
+    } finally {
+      setDeleteBusy(false);
+    }
+  };
+
+  const columns = [
+    {
+      key: 'coachType',
+      label: 'Fare class',
+      render: (row: ReschedulePolicyRow) => (
+        <div>
+          <span className="font-semibold text-foreground">{row.coachType?.code}</span>
+          <span className="text-muted-foreground">  -  {row.coachType?.name}</span>
+        </div>
+      ),
+    },
+    {
+      key: 'fee',
+      label: 'Change fee',
+      render: (row: ReschedulePolicyRow) => (
+        <span className="text-sm">{feeLabel(row.feePercent, row.feeMinMinor)}</span>
+      ),
+    },
+    {
+      key: 'routeChangeAllowed',
+      label: 'Route change',
+      render: (row: ReschedulePolicyRow) => (
+        <span className={`edr-badge ${row.routeChangeAllowed ? 'edr-badge-success' : 'edr-badge-danger'}`}>
+          {row.routeChangeAllowed ? 'Allowed' : 'Not permitted'}
+        </span>
+      ),
+    },
+    {
+      key: 'sameDay',
+      label: 'Same-day change',
+      render: (row: ReschedulePolicyRow) =>
+        row.sameDayAllowed ? (
+          <span className="text-sm">{feeLabel(row.sameDayFeePercent, row.sameDayFeeMinMinor)}</span>
+        ) : (
+          <span className="edr-badge edr-badge-danger">Not permitted</span>
+        ),
+    },
+    {
+      key: 'cutoffMinutes',
+      label: 'Cutoff',
+      render: (row: ReschedulePolicyRow) => (
+        <span className="font-mono text-sm">{row.cutoffMinutes} min</span>
+      ),
+    },
+    {
+      key: 'isActive',
+      label: 'Status',
+      render: (row: ReschedulePolicyRow) => (
+        <span className={`edr-badge ${row.isActive ? 'edr-badge-success' : 'edr-badge-warning'}`}>
+          {row.isActive ? 'Active' : 'Disabled'}
+        </span>
+      ),
+    },
+  ];
+
+  const actions = [
+    { label: 'Edit', onClick: openEdit, variant: 'secondary' as const, icon: Edit },
+    {
+      label: 'Delete',
+      onClick: (row: ReschedulePolicyRow) => setDeleting(row),
+      variant: 'danger' as const,
+      icon: Trash2,
+    },
+  ];
+
+  return (
+    <div className="space-y-4">
+      <div className="flex items-start justify-between gap-4">
+        {/* The page supplies the title; this is the rule-of-thumb the table's numbers mean. */}
+        <p className="text-xs text-muted-foreground max-w-3xl">
+          Fee = max(fee % × original leg fare, minimum). A higher new fare is always charged on top; a lower one is
+          not refunded. Same-day = new departure on the same calendar day as the original. A fare class with no
+          policy here cannot be rescheduled at all.
+        </p>
+        <ActionButton icon={Plus} onClick={openCreate} disabled={available.length === 0}>
+          Add Reschedule Policy
+        </ActionButton>
+      </div>
+
+      {!loading && available.length === 0 && (
+        <p className="text-xs text-muted-foreground">Every fare class already has a policy.</p>
+      )}
+      {message && <p className="text-sm text-muted-foreground">{message}</p>}
+
+      <DataTable
+        data={rows}
+        columns={columns}
+        actions={actions}
+        loading={loading}
+        emptyMessage="No reschedule policies yet  -  add one to allow rescheduling."
+      />
+
+      <Modal
+        isOpen={showModal}
+        onClose={() => setShowModal(false)}
+        title={editing ? `Edit Reschedule Policy  -  ${editing.coachType?.code}` : 'Add Reschedule Policy'}
+        size="lg"
+      >
+        <div className="space-y-4">
+          <div className="space-y-1">
+            <label className="label">Fare class</label>
+            {editing ? (
+              <>
+                <input
+                  className="input"
+                  value={`${editing.coachType?.code}  -  ${editing.coachType?.name}`}
+                  disabled
+                />
+                {/* One policy per fare class, so editing never re-points a row at another class. */}
+                <p className="text-xs text-muted-foreground">A policy stays attached to its fare class.</p>
+              </>
+            ) : (
+              <select className="input" value={coachTypeId} onChange={(e) => setCoachTypeId(e.target.value)}>
+                <option value="">Select a fare class...</option>
+                {available.map((ct) => (
+                  <option key={ct.id} value={ct.id}>
+                    {ct.code}  -  {ct.name}
+                  </option>
+                ))}
+              </select>
+            )}
+          </div>
+
+          <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+            <div className="space-y-1">
+              <label className="label">Fee (% of fare)</label>
+              <input
+                type="number"
+                min="0"
+                max="100"
+                className="input"
+                value={form.feePercent}
+                onChange={(e) => setField({ feePercent: Number(e.target.value) })}
+              />
+            </div>
+            <div className="space-y-1">
+              <label className="label">Minimum fee (ETB)</label>
+              <input
+                type="number"
+                min="0"
+                step="0.01"
+                className="input"
+                value={etb(form.feeMinMinor)}
+                onChange={(e) => setField({ feeMinMinor: toMinor(e.target.value) })}
+              />
+            </div>
+            <div className="space-y-1">
+              <label className="label">Cutoff before departure (min)</label>
+              <input
+                type="number"
+                min="0"
+                className="input"
+                value={form.cutoffMinutes}
+                onChange={(e) => setField({ cutoffMinutes: Number(e.target.value) })}
+              />
+            </div>
+            <div className="space-y-1">
+              <label className="label">Route change</label>
+              <label className="flex items-center gap-2 text-sm h-10">
+                <input
+                  type="checkbox"
+                  checked={form.routeChangeAllowed}
+                  onChange={(e) => setField({ routeChangeAllowed: e.target.checked })}
+                />
+                Allowed
+              </label>
+            </div>
+            <div className="space-y-1">
+              <label className="label">Same-day change</label>
+              <label className="flex items-center gap-2 text-sm h-10">
+                <input
+                  type="checkbox"
+                  checked={form.sameDayAllowed}
+                  onChange={(e) => setField({ sameDayAllowed: e.target.checked })}
+                />
+                Allowed
+              </label>
+            </div>
+            <div className="space-y-1">
+              <label className="label">Status</label>
+              <label className="flex items-center gap-2 text-sm h-10">
+                <input
+                  type="checkbox"
+                  checked={form.isActive}
+                  onChange={(e) => setField({ isActive: e.target.checked })}
+                />
+                Active
+              </label>
+            </div>
+            <div className="space-y-1">
+              <label className="label">Same-day fee (% of fare)</label>
+              <input
+                type="number"
+                min="0"
+                max="100"
+                className="input"
+                disabled={!form.sameDayAllowed}
+                value={form.sameDayFeePercent}
+                onChange={(e) => setField({ sameDayFeePercent: Number(e.target.value) })}
+              />
+            </div>
+            <div className="space-y-1">
+              <label className="label">Same-day minimum fee (ETB)</label>
+              <input
+                type="number"
+                min="0"
+                step="0.01"
+                className="input"
+                disabled={!form.sameDayAllowed}
+                value={etb(form.sameDayFeeMinMinor)}
+                onChange={(e) => setField({ sameDayFeeMinMinor: toMinor(e.target.value) })}
+              />
+            </div>
+          </div>
+
+          {formError && <p className="text-sm text-red-600 dark:text-red-400">{formError}</p>}
+
+          <div className="flex justify-end gap-2 pt-2">
+            <ActionButton variant="secondary" onClick={() => setShowModal(false)}>
+              Cancel
+            </ActionButton>
+            <ActionButton icon={Save} onClick={submit} loading={saving}>
+              {editing ? 'Update Policy' : 'Create Policy'}
+            </ActionButton>
+          </div>
+        </div>
+      </Modal>
+
+      <ConfirmDialog
+        isOpen={!!deleting}
+        onClose={() => setDeleting(null)}
+        onConfirm={confirmDelete}
+        title="Delete reschedule policy"
+        message={`Delete the reschedule policy for ${deleting?.coachType?.code ?? ''}?`}
+        warning="Passengers on this fare class will no longer be able to reschedule. Bookings already rescheduled are unaffected."
+        confirmText="Delete"
+        isDanger
+        isLoading={deleteBusy}
+      />
+    </div>
+  );
+}
diff --git a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
index cede0b966..f444adda8 100644
--- a/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
+++ b/apps/edr-passenger-web/backoffice/src/lib/api/index.ts
@@ -542,6 +542,40 @@ export const systemConfigApi = {
   update: (data: Record<string, string>) => apiClient.patch<Record<string, string>>('/config', data),
 };
 
+// Reschedule Policy API — one policy per coach type (fare class). A coach type with no policy
+// simply has no row, and rescheduling is refused for it.
+export interface ReschedulePolicyValues {
+  feePercent: number;
+  feeMinMinor: number;
+  routeChangeAllowed: boolean;
+  sameDayAllowed: boolean;
+  sameDayFeePercent: number;
+  sameDayFeeMinMinor: number;
+  cutoffMinutes: number;
+  isActive: boolean;
+}
+export interface ReschedulePolicyCoachType {
+  id: string;
+  code: string;
+  name: string;
+  type: string;
+}
+export interface ReschedulePolicyRow extends ReschedulePolicyValues {
+  id: string;
+  coachTypeId: string;
+  coachType: ReschedulePolicyCoachType;
+}
+export const reschedulePolicyApi = {
+  list: () => apiClient.get<ReschedulePolicyRow[]>('/reschedule/policies'),
+  availableCoachTypes: () =>
+    apiClient.get<ReschedulePolicyCoachType[]>('/reschedule/policies/available-coach-types'),
+  create: (data: ReschedulePolicyValues & { coachTypeId: string }) =>
+    apiClient.post<ReschedulePolicyRow>('/reschedule/policies', data),
+  update: (coachTypeId: string, data: Partial<ReschedulePolicyValues>) =>
+    apiClient.patch<ReschedulePolicyRow>(`/reschedule/policies/${coachTypeId}`, data),
+  remove: (coachTypeId: string) => apiClient.delete<any>(`/reschedule/policies/${coachTypeId}`),
+};
+
 // App Releases API
 export const appReleasesApi = {
   getAll: async () => {
diff --git a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
index d42ab0dc3..ab3a6376f 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/detail/page.tsx
@@ -4,6 +4,8 @@ import { Suspense } from "react";
 import { useSearchParams, useRouter } from "next/navigation";
 import { useQuery, useMutation } from "@tanstack/react-query";
 import { apiClient } from "@/lib/api-client";
+import { useAuthStore } from "@/lib/auth-store";
+import { samePhone } from "@/utils/phone";
 import { resolvePaymentRedirectUrl } from "@/lib/payment-redirect";
 import { useEffect, useState } from "react";
 import {
@@ -78,6 +80,13 @@ function BookingDetailContent() {
     searchParams.get("bookingRef") ||
     searchParams.get("pnr");
 
+  // `isInitialized` gates on the auth store having read localStorage. Without it a signed-in
+  // user watches the Reschedule button appear a beat after the page, because the store starts
+  // every render as logged-out. AppSidebar calls initialize() from the root layout.
+  const isAuthenticated = useAuthStore((s) => s.isAuthenticated);
+  const isAuthInitialized = useAuthStore((s) => s.isInitialized);
+  const currentUserPhone = useAuthStore((s) => s.user?.phone);
+
   // Mirrors /booking/payment's state shape: selectedMethod is the PaymentMethod `type`
   // (used both for lookup and to decide provider-specific redirect handling), not the id.
   const [selectedMethod, setSelectedMethod] = useState<string | null>(null);
@@ -329,6 +338,20 @@ function BookingDetailContent() {
   const isExpired = booking.status === "EXPIRED";
   const isCancelled = booking.status === "CANCELLED";
 
+  // Whether this booking is the kind that can be rescheduled at all. The per-leg rules
+  // (fare-class policy, cutoff, already-boarded) are the API's call and are shown on the
+  // reschedule page itself; this is only the coarse shape test.
+  const bookingSupportsReschedule =
+    !booking.isPackageBooking &&
+    ["ONE_WAY", "ROUND_TRIP"].includes(booking.bookingType) &&
+    !booking.outboundBoardedAt;
+
+  const isBooker = samePhone(currentUserPhone, booking.contactPhone);
+
+  const canReschedule = isAuthenticated && (isBooker || !booking.contactPhone);
+
+  const reschedulePath = `/booking/reschedule?ref=${booking.bookingRef}`;
+
   const StatusBadge = () => {
     const statusConfig = {
       PENDING_PAYMENT: {
@@ -1022,6 +1045,31 @@ function BookingDetailContent() {
                         </>
                       )}
                     </button>
+                    {/* Rescheduling is account-only: every /bookings/:ref/reschedule route sits behind
+                        JwtGuard and resolves ownership from the signed-in IAM user. A guest who got
+                        here through booking lookup (ref + phone) has no session, so instead of hiding
+                        the option we name the blocker and send them somewhere that fixes it. */}
+                    {bookingSupportsReschedule && (!isAuthInitialized || !isAuthenticated || canReschedule) && (
+                      <button
+                        disabled={!isAuthInitialized}
+                        onClick={() =>
+                          router.push(
+                            isAuthenticated
+                              ? reschedulePath
+                              : `/login?redirect=${encodeURIComponent(reschedulePath)}`,
+                          )
+                        }
+                        title={
+                          isAuthenticated
+                            ? "Change the date, train or seats on this booking"
+                            : "Rescheduling needs an account — sign in to continue"
+                        }
+                        className="px-4 py-2 rounded-lg border border-gray-300 dark:border-gray-600 text-gray-700 dark:text-gray-200 hover:bg-gray-50 dark:hover:bg-gray-700 disabled:opacity-50 disabled:cursor-not-allowed flex items-center gap-2"
+                      >
+                        <Clock className="w-4 h-4" />
+                        {isAuthInitialized && !isAuthenticated ? "Sign in to reschedule" : "Reschedule"}
+                      </button>
+                    )}
                   </>
                 )}
               </div>
diff --git a/apps/edr-passenger-web/portal/src/app/booking/reschedule/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/reschedule/page.tsx
new file mode 100644
index 000000000..816d2547d
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/app/booking/reschedule/page.tsx
@@ -0,0 +1,772 @@
+"use client";
+
+import { Suspense, useEffect, useMemo, useRef, useState } from "react";
+import { useRouter, useSearchParams } from "next/navigation";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { format } from "date-fns";
+import { AlertCircle, ArrowRight, CheckCircle2, ChevronLeft, Loader2 } from "lucide-react";
+import { apiClient } from "@/lib/api-client";
+import { useAuthStore } from "@/lib/auth-store";
+import ModernDatePicker from "@/components/ModernDatePicker";
+import StationDropdown, {
+  pushRecentStation,
+  readRecentStationIds,
+} from "@/components/StationDropdown";
+import SeatMap, { buildSeatLabel, getValidSeatsForCoach } from "@/components/SeatMap";
+import { formatTime } from "@/utils/format";
+import { Station } from "@/types";
+
+// Same horizon the search widget uses — /search/available-dates is server-clamped to 90 days,
+// so the picker's maxDate has to match or unchecked future months render as pickable again.
+const AVAILABLE_DATES_RANGE_DAYS = 90;
+
+const toDateStr = (d: Date) =>
+  `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+
+interface AvailableDatesResponse {
+  routeExists: boolean;
+  dates: { date: string; available: boolean }[];
+}
+
+type LegOption = {
+  leg: number;
+  scheduleId: string;
+  originStationId: string | null;
+  destinationStationId: string | null;
+  departureAt: string;
+  coachTypeId: string;
+  seatCount: number;
+  passengerNames: string[];
+  oldFareMinor: number;
+  policy: {
+    feePercent: number;
+    feeMinMinor: number;
+    routeChangeAllowed: boolean;
+    sameDayAllowed: boolean;
+    sameDayFeePercent: number;
+    sameDayFeeMinMinor: number;
+    cutoffMinutes: number;
+  } | null;
+  canReschedule: boolean;
+  blockers: string[];
+};
+
+type Options = {
+  bookingRef: string;
+  bookingType: string;
+  legs: LegOption[];
+  pending: { id: string; amountDueMinor: number; paymentToken: string | null; expiresAt: string | null } | null;
+};
+
+type Quote = {
+  allowed: boolean;
+  blockers: string[];
+  oldFareMinor: number;
+  newFareMinor: number;
+  feeMinor: number;
+  fareDifferenceMinor: number;
+  amountDueMinor: number;
+  isSameDay: boolean;
+  isRouteChange: boolean;
+};
+
+const etb = (minor: number) => `ETB ${(minor / 100).toFixed(2)}`;
+
+/** "Sat 29 Aug, 21:00" — the summary's departure line. Null when the value isn't a real date. */
+const formatDepartureDay = (value: string | Date | undefined | null): string | null => {
+  if (!value) return null;
+  const d = value instanceof Date ? value : new Date(value);
+  return isNaN(d.getTime()) ? null : format(d, "EEE dd MMM, HH:mm");
+};
+
+function ReschedulePageContent() {
+  const router = useRouter();
+  const searchParams = useSearchParams();
+  const ref = searchParams.get("ref") || "";
+
+  // Every endpoint this page calls is behind JwtGuard, so a guest who deep-links here would
+  // otherwise watch the options request 401 and land on "This booking cannot be rescheduled" —
+  // which blames the booking for what is really a missing session. Send them to sign in and
+  // bring them straight back instead. Waits for isInitialized: the store starts logged-out.
+  const isAuthenticated = useAuthStore((s) => s.isAuthenticated);
+  const isAuthInitialized = useAuthStore((s) => s.isInitialized);
+  const needsLogin = isAuthInitialized && !isAuthenticated;
+
+  useEffect(() => {
+    if (!needsLogin) return;
+    const back = ref ? `/booking/reschedule?ref=${ref}` : "/booking/lookup";
+    router.replace(`/login?redirect=${encodeURIComponent(back)}`);
+  }, [needsLogin, ref, router]);
+
+  const [legNo, setLegNo] = useState(1);
+  const [date, setDate] = useState<Date | undefined>(undefined);
+  const [originId, setOriginId] = useState("");
+  const [destinationId, setDestinationId] = useState("");
+  const [searched, setSearched] = useState<{ originId: string; destinationId: string; date: string } | null>(null);
+  const [schedule, setSchedule] = useState<any | null>(null);
+  // Seat per passenger, keyed by index into leg.passengerNames. The API pairs newSeatIds[i]
+  // with the i-th BookingSeat in that same order, so an explicit map is the only way the
+  // right passenger keeps the right fare (a free child must not inherit an adult's seat).
+  const [passengerSeatMap, setPassengerSeatMap] = useState<Record<number, string>>({});
+  const [activePassengerIndex, setActivePassengerIndex] = useState(0);
+  const [selectedCoach, setSelectedCoach] = useState<string | null>(null);
+  const [done, setDone] = useState<{ status: string } | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [dateNotice, setDateNotice] = useState<string | null>(null);
+  const [recentStationIds, setRecentStationIds] = useState<string[]>(
+    readRecentStationIds,
+  );
+  const saveRecent = (id: string) =>
+    setRecentStationIds((prev) => pushRecentStation(id, prev));
+
+  const resetSeats = () => {
+    setPassengerSeatMap({});
+    setActivePassengerIndex(0);
+    setSelectedCoach(null);
+  };
+
+  const { data: options, isLoading: loadingOptions, error: optionsError } = useQuery<Options>({
+    queryKey: ["reschedule-options", ref],
+    queryFn: () => apiClient.get<Options>(`/bookings/${ref}/reschedule`),
+    // Never fire before the session is known — an unauthenticated call only 401s.
+    enabled: !!ref && isAuthInitialized && isAuthenticated,
+    retry: false,
+  });
+  const { data: stations = [] } = useQuery<Station[]>({
+    queryKey: ["stations"],
+    queryFn: () => apiClient.get<Station[]>("/stations"),
+  });
+
+  const leg = useMemo(() => options?.legs.find((l) => l.leg === legNo) ?? options?.legs[0], [options, legNo]);
+
+  // Prefill route from the leg being changed.
+  useEffect(() => {
+    if (!leg) return;
+    setOriginId(leg.originStationId ?? "");
+    setDestinationId(leg.destinationStationId ?? "");
+    setSchedule(null);
+    resetSeats();
+    setSearched(null);
+  }, [leg?.leg, leg?.scheduleId]);
+
+  const journeyDirection = leg?.leg === 2 ? "RETURN" : options?.bookingType === "ROUND_TRIP" ? "OUTBOUND" : "ONE_WAY";
+
+  // Which dates actually have a bookable train for the chosen From/To. Same endpoint and same
+  // shape the home-page search widget uses, so the reschedule calendar greys out the same days
+  // rather than letting someone pick a date that can only come back empty.
+  const { data: availableDates } = useQuery<AvailableDatesResponse>({
+    queryKey: ["available-dates", originId, destinationId],
+    queryFn: async () => {
+      const from = new Date();
+      const to = new Date();
+      to.setDate(to.getDate() + AVAILABLE_DATES_RANGE_DAYS);
+      return (await apiClient.get("/search/available-dates", {
+        params: {
+          originStationId: originId,
+          destinationStationId: destinationId,
+          from: toDateStr(from),
+          to: toDateStr(to),
+        },
+      })) as AvailableDatesResponse;
+    },
+    enabled: !!originId && !!destinationId && originId !== destinationId,
+    staleTime: 5 * 60 * 1000,
+  });
+
+  const disabledDates = useMemo(() => {
+    const set = new Set<string>();
+    // routeExists === false is handled by disabling the control outright (noRouteForPair):
+    // the server returns an empty `dates` array in that case anyway.
+    if (!availableDates?.routeExists) return set;
+    for (const d of availableDates.dates) if (!d.available) set.add(d.date);
+    return set;
+  }, [availableDates]);
+
+  const noRouteForPair =
+    !!originId && !!destinationId && availableDates?.routeExists === false;
+
+  const maxSearchDate = useMemo(() => {
+    const d = new Date();
+    d.setDate(d.getDate() + AVAILABLE_DATES_RANGE_DAYS);
+    return d;
+  }, []);
+
+  // If the picked date turns out to have no train (stations changed, or the availability query
+  // just resolved), drop it and say why — rather than letting "Find trains" return nothing.
+  useEffect(() => {
+    if (date && disabledDates.has(toDateStr(date))) {
+      setDate(undefined);
+      setSearched(null);
+      setSchedule(null);
+      resetSeats();
+      setDateNotice("No trains run this route on that date — please pick another.");
+    }
+  }, [date, disabledDates]);
+
+  // Losing the route invalidates any date already chosen, so nothing stale can be submitted
+  // from behind a now-disabled control.
+  useEffect(() => {
+    if (noRouteForPair && date) {
+      setDate(undefined);
+      setSearched(null);
+      setSchedule(null);
+      resetSeats();
+    }
+  }, [noRouteForPair, date]);
+
+  const { data: schedules = [], isFetching: searching } = useQuery<any[]>({
+    queryKey: ["reschedule-search", searched],
+    queryFn: async () => {
+      const res: any = await apiClient.post("/search", {
+        originStationId: searched!.originId,
+        destinationStationId: searched!.destinationId,
+        date: searched!.date,
+        adultCount: leg?.seatCount ?? 1,
+        childCount: 0,
+        journeyType: "ONE_WAY",
+      });
+      const list = Array.isArray(res) ? res : res?.outbound ?? res?.data ?? [];
+      return list.filter((s: any) => (s.scheduleId || s.id) !== leg?.scheduleId || searched!.originId !== leg?.originStationId || searched!.destinationId !== leg?.destinationStationId);
+    },
+    enabled: !!searched && !!leg,
+  });
+
+  const scheduleId = schedule ? schedule.scheduleId || schedule.id : null;
+  const { data: seatMap, isLoading: loadingSeats } = useQuery<any>({
+    queryKey: ["reschedule-seatmap", scheduleId, leg?.coachTypeId, originId, destinationId],
+    queryFn: async () => {
+      const res: any = await apiClient.get(
+        `/seats/seatmap/${scheduleId}?coachTypeId=${leg!.coachTypeId}&journeyDirection=${journeyDirection}&originStationId=${originId}&destinationStationId=${destinationId}`,
+      );
+      return res?.data || res;
+    },
+    enabled: !!scheduleId && !!leg,
+  });
+
+  const coaches: any[] = useMemo(() => seatMap?.coaches ?? [], [seatMap]);
+
+  // Expand the first coach automatically — with one coach of the booked class on most trains,
+  // making the user open it before any seat is visible is a click for nothing. Fires once per
+  // schedule: keying it on `selectedCoach` instead would re-open the coach the moment the user
+  // collapsed it, since collapsing sets selectedCoach back to null.
+  const autoExpandedFor = useRef<string | null>(null);
+  useEffect(() => {
+    if (!scheduleId || coaches.length === 0) return;
+    if (autoExpandedFor.current === scheduleId) return;
+    autoExpandedFor.current = scheduleId;
+    setSelectedCoach(coaches[0].id);
+  }, [scheduleId, coaches]);
+
+  // newSeatIds must line up with the leg's BookingSeats, which the API orders by passenger
+  // name — the same order `passengerNames` arrives in. Indexing by passenger builds that
+  // order by construction, so there is nothing for a click sequence to get wrong.
+  const orderedSeatIds = useMemo(
+    () => Array.from({ length: leg?.seatCount ?? 0 }, (_, i) => passengerSeatMap[i]).filter(Boolean) as string[],
+    [passengerSeatMap, leg?.seatCount],
+  );
+  const allSeatsChosen = !!leg && orderedSeatIds.length === leg.seatCount;
+
+  const isSeatSelected = (seatId: string) => passengerSeatMap[activePassengerIndex] === seatId;
+  const isSeatAssignedToOther = (seatId: string) =>
+    Object.entries(passengerSeatMap).some(
+      ([idx, sid]) => Number(idx) !== activePassengerIndex && sid === seatId,
+    );
+
+  const handleSeatToggle = (seatId: string) => {
+    if (isSeatAssignedToOther(seatId)) return;
+    setPassengerSeatMap((prev) => {
+      const next = { ...prev };
+      if (next[activePassengerIndex] === seatId) {
+        delete next[activePassengerIndex];
+        return next;
+      }
+      next[activePassengerIndex] = seatId;
+      // Move to the next passenger still without a seat so a multi-passenger leg can be
+      // filled by clicking straight down the coach.
+      const total = leg?.seatCount ?? 1;
+      const nextUnassigned = Array.from({ length: total }, (_, i) => i).find((i) => !next[i]);
+      if (nextUnassigned !== undefined) setActivePassengerIndex(nextUnassigned);
+      return next;
+    });
+  };
+
+  // No skipping ahead of a passenger who still needs a seat — same rule as /booking/seats.
+  const firstUnassignedIndex = Array.from({ length: leg?.seatCount ?? 0 }, (_, i) => i).find(
+    (i) => !passengerSeatMap[i],
+  );
+  const maxSelectableIndex =
+    firstUnassignedIndex === undefined ? (leg?.seatCount ?? 1) - 1 : firstUnassignedIndex;
+
+  const quoteBody = leg && scheduleId && allSeatsChosen
+    ? { leg: leg.leg, newScheduleId: scheduleId, newOriginStationId: originId, newDestinationStationId: destinationId, newSeatIds: orderedSeatIds }
+    : null;
+  const { data: quote, isFetching: quoting } = useQuery<Quote>({
+    queryKey: ["reschedule-quote", ref, quoteBody],
+    queryFn: () => apiClient.post<Quote>(`/bookings/${ref}/reschedule/quote`, quoteBody),
+    enabled: !!quoteBody,
+  });
+
+  const confirm = useMutation({
+    mutationFn: async () => {
+      const hold: any = await apiClient.post("/seats/hold", {
+        scheduleId,
+        originStationId: originId,
+        destinationStationId: destinationId,
+        journeyDirection,
+        passengers: orderedSeatIds.map((seatId, i) => ({ passengerId: `reschedule-${ref}-${i}`, seatId })),
+      });
+      return apiClient.post<any>(`/bookings/${ref}/reschedule`, { ...quoteBody, holdId: hold.holdId || hold.id });
+    },
+    onSuccess: (res) => {
+      if (res.paymentToken) router.push(`/pay-balance/${res.paymentToken}`);
+      else setDone({ status: res.status });
+    },
+    onError: (e: any) => setError(e?.response?.data?.message || e?.message || "Could not reschedule"),
+  });
+
+  const stationName = (id: string | null) => stations.find((s) => s.id === id)?.name ?? id ?? "—";
+
+  if (!ref) return <Shell><p className="text-gray-600">Missing booking reference.</p></Shell>;
+  // Hold the spinner through the redirect rather than flashing the booking's error state.
+  if (!isAuthInitialized || needsLogin) {
+    return <Shell><Loader2 className="w-6 h-6 animate-spin text-primary" /></Shell>;
+  }
+  if (loadingOptions) return <Shell><Loader2 className="w-6 h-6 animate-spin text-primary" /></Shell>;
+  if (optionsError || !options || !leg) {
+    return <Shell><p className="text-red-600">{(optionsError as any)?.response?.data?.message || "This booking cannot be rescheduled."}</p></Shell>;
+  }
+
+  if (done) {
+    return (
+      <Shell>
+        <div className="text-center space-y-4">
+          <CheckCircle2 className="w-14 h-14 text-green-600 mx-auto" />
+          <h1 className="text-2xl font-bold text-gray-900 dark:text-white">Booking rescheduled</h1>
+          <p className="text-gray-600 dark:text-gray-400">New tickets have been issued for booking {ref}.</p>
+          <button className="btn-primary" onClick={() => router.push(`/booking/detail?ref=${ref}`)}>View booking</button>
+        </div>
+      </Shell>
+    );
+  }
+
+  if (options.pending) {
+    return (
+      <Shell>
+        <div className="space-y-4">
+          <h1 className="text-2xl font-bold text-gray-900 dark:text-white">Reschedule awaiting payment</h1>
+          <p className="text-gray-600 dark:text-gray-400">
+            A change of {etb(options.pending.amountDueMinor)} is waiting to be paid
+            {options.pending.expiresAt ? ` before ${format(new Date(options.pending.expiresAt), "dd MMM HH:mm")}` : ""}.
+            Your new seats are held until then.
+          </p>
+          {options.pending.paymentToken && (
+            <button className="btn-primary" onClick={() => router.push(`/pay-balance/${options.pending!.paymentToken}`)}>Pay now</button>
+          )}
+        </div>
+      </Shell>
+    );
+  }
+
+  const routeLocked = !leg.policy?.routeChangeAllowed;
+
+  // Short label/value pairs rather than prose — the rules are scanned, not read.
+  const fareRules = leg.policy
+    ? [
+        {
+          label: "Change fee",
+          value:
+            leg.policy.feePercent > 0 || leg.policy.feeMinMinor > 0
+              ? `${leg.policy.feePercent}% of fare (min ${etb(leg.policy.feeMinMinor)})`
+              : "Free",
+        },
+        { label: "Route change", value: leg.policy.routeChangeAllowed ? "Allowed" : "Not permitted" },
+        {
+          label: "Same-day change",
+          value: !leg.policy.sameDayAllowed
+            ? "Not permitted"
+            : leg.policy.sameDayFeePercent > 0 || leg.policy.sameDayFeeMinMinor > 0
+              ? `${leg.policy.sameDayFeePercent}% (min ${etb(leg.policy.sameDayFeeMinMinor)})`
+              : "Free",
+        },
+        { label: "Changes close", value: `${leg.policy.cutoffMinutes} min before departure` },
+        { label: "Higher new fare", value: "Payable" },
+        { label: "Lower new fare", value: "Not refunded" },
+      ]
+    : [];
+
+  const canSearch =
+    !!date && !!originId && !!destinationId && originId !== destinationId && !noRouteForPair;
+
+  // Mirrors the booking flow's FareSidebar: a sticky money card that is present from the
+  // start and fills in as choices are made, rather than a total that appears at the end.
+  // Rendered twice — inline under the content on mobile, sticky beside it on desktop.
+  const ChangeSummary = () => (
+    <div className="card space-y-3">
+      <h2 className="text-base font-bold text-gray-900 dark:text-gray-100 pb-2 border-b border-gray-100 dark:border-gray-800">
+        Change summary
+      </h2>
+
+      <div>
+        <div className="text-[10px] font-semibold uppercase tracking-wide text-gray-400 mb-1">Currently</div>
+        <div className="text-sm font-medium text-gray-900 dark:text-gray-100">
+          {formatDepartureDay(leg.departureAt)}
+        </div>
+        <div className="text-xs text-gray-500 dark:text-gray-400">
+          {stationName(leg.originStationId)} → {stationName(leg.destinationStationId)}
+        </div>
+      </div>
+
+      {schedule && (
+        <div className="pt-3 border-t border-gray-100 dark:border-gray-800">
+          <div className="text-[10px] font-semibold uppercase tracking-wide text-gray-400 mb-1">Changing to</div>
+          {/* Same date+time line as "Currently" above, so the two are read side by side. */}
+          <div className="text-sm font-medium text-gray-900 dark:text-gray-100">
+            {formatDepartureDay(schedule.departureAt) ?? formatTime(schedule.departureAt)}
+          </div>
+          <div className="text-xs text-gray-500 dark:text-gray-400">
+            {schedule.trainName || schedule.trainNumber} · arrives {formatTime(schedule.arrivalAt)}
+          </div>
+          <div className="text-xs text-gray-500 dark:text-gray-400">
+            {stationName(originId)} → {stationName(destinationId)}
+          </div>
+        </div>
+      )}
+
+      <div className="pt-3 border-t border-gray-100 dark:border-gray-800 space-y-1">
+        {leg.passengerNames.map((name, i) => {
+          const seatId = passengerSeatMap[i];
+          const seat = seatId
+            ? coaches.flatMap((c: any) => getValidSeatsForCoach(c)).find((s: any) => s.id === seatId)
+            : null;
+          return (
+            <div key={`sum-${name}-${i}`} className="flex justify-between text-sm">
+              <span className="text-gray-700 dark:text-gray-300 truncate max-w-[60%]">{name}</span>
+              <span className={seat ? "font-semibold text-gray-900 dark:text-gray-100" : "text-gray-400"}>
+                {seat ? `Seat ${buildSeatLabel(seat)}` : "—"}
+              </span>
+            </div>
+          );
+        })}
+      </div>
+
+      {!quoteBody ? (
+        <p className="text-xs text-gray-500 dark:text-gray-400 pt-3 border-t border-gray-100 dark:border-gray-800">
+          Pick a new train and a seat for {leg.seatCount > 1 ? "every passenger" : "the passenger"} to see what this change costs.
+        </p>
+      ) : quoting ? (
+        <div className="pt-3 border-t border-gray-100 dark:border-gray-800">
+          <Loader2 className="w-5 h-5 animate-spin text-primary" />
+        </div>
+      ) : quote ? (
+        <div className="pt-3 border-t border-gray-100 dark:border-gray-800 space-y-2 text-sm">
+          <Row label="Original fare" value={etb(quote.oldFareMinor)} />
+          <Row label="New fare" value={etb(quote.newFareMinor)} />
+          <Row
+            label={quote.fareDifferenceMinor >= 0 ? "Fare difference" : "Fare difference (not refunded)"}
+            value={etb(Math.max(0, quote.fareDifferenceMinor))}
+          />
+          <Row label={`Change fee${quote.isSameDay ? " (same-day)" : ""}`} value={etb(quote.feeMinor)} />
+          <div className="flex justify-between items-center pt-2 border-t border-gray-200 dark:border-gray-700">
+            <span className="font-bold text-gray-900 dark:text-gray-100">Total due now</span>
+            <span className="text-xl font-bold text-primary">{etb(quote.amountDueMinor)}</span>
+          </div>
+          {quote.blockers.length > 0 && (
+            <div className="text-red-600 flex gap-2 text-xs">
+              <AlertCircle className="w-4 h-4 shrink-0 mt-0.5" />
+              <div>{quote.blockers.map((b) => <div key={b}>{b}</div>)}</div>
+            </div>
+          )}
+          {error && <div className="text-red-600 text-xs">{error}</div>}
+          <button
+            className="btn-primary w-full mt-1"
+            disabled={!quote.allowed || confirm.isPending}
+            onClick={() => { setError(null); confirm.mutate(); }}
+          >
+            {confirm.isPending
+              ? "Processing..."
+              : quote.amountDueMinor > 0
+                ? `Continue to payment · ${etb(quote.amountDueMinor)}`
+                : "Confirm reschedule"}
+          </button>
+        </div>
+      ) : null}
+    </div>
+  );
+
+  return (
+    <Shell wide>
+      <button onClick={() => router.push(`/booking/detail?ref=${ref}`)} className="flex items-center gap-1 text-sm text-gray-500 mb-4">
+        <ChevronLeft className="w-4 h-4" /> Back to booking
+      </button>
+      <h1 className="text-2xl font-bold text-gray-900 dark:text-white mb-1">Reschedule {ref}</h1>
+      <p className="text-sm text-gray-600 dark:text-gray-400 mb-6">
+        {leg.passengerNames.join(", ")} · currently {format(new Date(leg.departureAt), "EEE dd MMM, HH:mm")} · {stationName(leg.originStationId)} → {stationName(leg.destinationStationId)}
+      </p>
+
+      {options.legs.length > 1 && (
+        <div className="flex gap-2 mb-6">
+          {options.legs.map((l) => (
+            <button key={l.leg} onClick={() => setLegNo(l.leg)} className={`px-4 py-2 rounded-lg border text-sm ${legNo === l.leg ? "border-primary text-primary" : "border-gray-200 text-gray-600"}`}>
+              {l.leg === 1 ? "Outbound" : "Return"} · {format(new Date(l.departureAt), "dd MMM")}
+            </button>
+          ))}
+        </div>
+      )}
+
+      {/* No `items-start` here on purpose: it shrinks each column to its own content height, and a
+          sticky child can only travel inside its containing block — so the summary would scroll
+          away like a normal card. The grid default (stretch) gives the right column the full row
+          height to stick within. */}
+      <div className="lg:grid lg:grid-cols-3 lg:gap-6">
+        {/* Left column — the choices */}
+        <div className="lg:col-span-2 space-y-4">
+        <div className="bg-white dark:bg-gray-800 rounded-2xl p-6 border border-gray-100 dark:border-gray-700 shadow-sm">
+      {fareRules.length > 0 && (
+        <div className="rounded-xl bg-gray-50 dark:bg-gray-900 border border-gray-200 dark:border-gray-700 p-4 mb-6">
+          <div className="font-semibold text-sm text-gray-900 dark:text-white mb-2.5">Your fare rules</div>
+          <ul className="grid sm:grid-cols-2 gap-x-6 gap-y-2">
+            {fareRules.map((rule) => (
+              <li key={rule.label} className="flex items-start gap-2">
+                <span className="mt-1.5 w-1.5 h-1.5 rounded-full bg-primary flex-shrink-0" />
+                <span className="text-sm leading-snug text-gray-600 dark:text-gray-400">
+                  {rule.label}:{" "}
+                  <span className="font-medium text-gray-900 dark:text-white">{rule.value}</span>
+                </span>
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
+
+      {!leg.canReschedule && (
+        <div className="rounded-xl bg-red-50 dark:bg-red-900/20 border border-red-200 p-4 text-sm text-red-700 mb-6 flex gap-2">
+          <AlertCircle className="w-5 h-5 shrink-0" />
+          <div>{leg.blockers.map((b) => <div key={b}>{b}</div>)}</div>
+        </div>
+      )}
+
+      {leg.canReschedule && (
+        <>
+          {/* Step 1: route + date */}
+          <div className="grid md:grid-cols-4 gap-3 mb-4">
+            <StationDropdown
+              stations={stations}
+              value={originId}
+              excludeId={destinationId}
+              placeholder="From"
+              recentIds={recentStationIds}
+              disabled={routeLocked}
+              onSelect={(s) => {
+                setOriginId(s.id);
+                if (s.id) saveRecent(s.id);
+                setDateNotice(null);
+                setSchedule(null);
+                resetSeats();
+                setSearched(null);
+              }}
+            />
+            <StationDropdown
+              stations={stations}
+              value={destinationId}
+              excludeId={originId}
+              placeholder="To"
+              recentIds={recentStationIds}
+              disabled={routeLocked}
+              onSelect={(s) => {
+                setDestinationId(s.id);
+                if (s.id) saveRecent(s.id);
+                setDateNotice(null);
+                setSchedule(null);
+                resetSeats();
+                setSearched(null);
+              }}
+            />
+            <ModernDatePicker
+              value={date}
+              onChange={(d) => {
+                setDateNotice(null);
+                setDate(d);
+              }}
+              minDate={new Date()}
+              maxDate={originId && destinationId ? maxSearchDate : undefined}
+              disabledDates={disabledDates}
+              disabled={noRouteForPair}
+              placeholder="New date"
+            />
+            <button className="btn-primary" disabled={!canSearch || searching} onClick={() => { setSchedule(null); resetSeats(); setSearched({ originId, destinationId, date: format(date!, "yyyy-MM-dd") }); }}>
+              {searching ? "Searching..." : "Find trains"}
+            </button>
+          </div>
+          {routeLocked && (
+            <p className="text-xs text-gray-500 dark:text-gray-400 -mt-2 mb-4">
+              Your fare class does not permit changing stations — only the date and train.
+            </p>
+          )}
+          {noRouteForPair && (
+            <p className="text-xs text-amber-600 dark:text-amber-400 -mt-2 mb-4">
+              No route connects these stations — pick a different destination.
+            </p>
+          )}
+          {dateNotice && !noRouteForPair && (
+            <p className="text-xs text-amber-600 dark:text-amber-400 -mt-2 mb-4">{dateNotice}</p>
+          )}
+
+          {/* Step 2: schedule */}
+          {searched && !searching && schedules.length === 0 && <p className="text-sm text-gray-500 mb-4">No trains on that day.</p>}
+          {schedules.length > 0 && (
+            <div className="space-y-2 mb-6">
+              {schedules.map((s: any) => {
+                const id = s.scheduleId || s.id;
+                const selected = scheduleId === id;
+                return (
+                  <button key={id} disabled={s.hasAvailability === false} onClick={() => { setSchedule(s); resetSeats(); }}
+                    className={`w-full text-left rounded-xl border p-4 flex items-center justify-between ${selected ? "border-primary bg-primary/5" : "border-gray-200 dark:border-gray-700"} disabled:opacity-50`}>
+                    <div>
+                      <div className="font-semibold text-gray-900 dark:text-white">{s.trainName || s.trainNumber}</div>
+                      <div className="text-sm text-gray-500">{formatTime(s.departureAt)} <ArrowRight className="inline w-3 h-3" /> {formatTime(s.arrivalAt)}</div>
+                    </div>
+                    <div className="text-xs text-gray-500">{s.hasAvailability === false ? "Sold out" : "Select"}</div>
+                  </button>
+                );
+              })}
+            </div>
+          )}
+
+          {/* Step 3: seats (same class as booked) */}
+          {scheduleId && (
+            <div className="mb-6">
+              <h2 className="font-semibold text-gray-900 dark:text-white mb-1">
+                Pick {leg.seatCount} seat{leg.seatCount > 1 ? "s" : ""} ({orderedSeatIds.length}/{leg.seatCount})
+              </h2>
+              <p className="text-xs text-gray-500 dark:text-gray-400 mb-3">
+                {allSeatsChosen
+                  ? "Every passenger has a seat."
+                  : `Choosing a seat for ${leg.passengerNames[activePassengerIndex] ?? `Passenger ${activePassengerIndex + 1}`}.`}
+              </p>
+
+              {/* Who gets which seat. The API pairs seats to passengers by position, so this
+                  mapping is the payload — not a display convenience. */}
+              <div className="mb-4 rounded-xl border border-gray-200 dark:border-gray-700 divide-y divide-gray-100 dark:divide-gray-800">
+                {leg.passengerNames.map((name, i) => {
+                  const assignedSeatId = passengerSeatMap[i];
+                  const assignedSeat = assignedSeatId
+                    ? coaches.flatMap((c: any) => getValidSeatsForCoach(c)).find((s: any) => s.id === assignedSeatId)
+                    : null;
+                  const isActive = i === activePassengerIndex;
+                  const isClickable = i <= maxSelectableIndex;
+                  return (
+                    <button
+                      key={`${name}-${i}`}
+                      type="button"
+                      onClick={() => isClickable && setActivePassengerIndex(i)}
+                      disabled={!isClickable}
+                      className={`w-full flex items-center justify-between py-2 px-3 text-left transition-all ${
+                        isActive ? "bg-[rgb(20,113,76)]/5 dark:bg-[rgb(20,113,76)]/10" : ""
+                      } ${
+                        isClickable
+                          ? "cursor-pointer hover:bg-gray-50 dark:hover:bg-gray-800/60"
+                          : "cursor-not-allowed opacity-50"
+                      }`}
+                    >
+                      <div className="flex items-center gap-2 min-w-0">
+                        <div
+                          className={`w-6 h-6 rounded-full flex items-center justify-center text-xs font-bold flex-shrink-0 ${
+                            assignedSeat
+                              ? "bg-[rgb(20,113,76)] text-white"
+                              : isActive
+                                ? "bg-[rgb(20,113,76)]/20 text-[rgb(20,113,76)] ring-2 ring-[rgb(20,113,76)]"
+                                : "bg-gray-200 dark:bg-gray-700 text-gray-500"
+                          }`}
+                        >
+                          {i + 1}
+                        </div>
+                        <div className="min-w-0">
+                          <span className="text-sm text-gray-700 dark:text-gray-300 truncate block max-w-[160px]">
+                            {name}
+                          </span>
+                          {isActive && !assignedSeat && (
+                            <span className="text-[10px] font-semibold text-[rgb(20,113,76)] uppercase tracking-wide">
+                              Now selecting
+                            </span>
+                          )}
+                        </div>
+                      </div>
+                      <span
+                        className={`text-sm font-semibold flex-shrink-0 ${
+                          assignedSeat ? "text-[rgb(20,113,76)]" : "text-gray-400"
+                        }`}
+                      >
+                        {assignedSeat ? `Seat ${buildSeatLabel(assignedSeat)}` : "Not Assigned"}
+                      </span>
+                    </button>
+                  );
+                })}
+              </div>
+
+              {loadingSeats ? (
+                <Loader2 className="w-5 h-5 animate-spin text-primary" />
+              ) : (
+                <SeatMap
+                  coaches={coaches}
+                  selectedCoachId={selectedCoach}
+                  onSelectCoach={setSelectedCoach}
+                  isSeatSelected={isSeatSelected}
+                  isSeatAssignedToOther={isSeatAssignedToOther}
+                  onSeatToggle={handleSeatToggle}
+                />
+              )}
+            </div>
+          )}
+
+        </>
+      )}
+        </div>{/* end left card */}
+
+          {/* Mobile: the summary sits under the choices instead of beside them */}
+          <div className="lg:hidden">
+            <ChangeSummary />
+          </div>
+        </div>{/* end left column */}
+
+        {/* Right column — sticky change summary (desktop only) */}
+        <div className="hidden lg:block">
+          {/* Caps at the viewport and scrolls inside itself, so a long passenger list can't push
+              the total and the confirm button off the bottom of the screen. */}
+          <div className="sticky top-6 max-h-[calc(100vh-3rem)] overflow-y-auto">
+            <ChangeSummary />
+          </div>
+        </div>
+      </div>
+    </Shell>
+  );
+}
+
+function Row({ label, value }: { label: string; value: string }) {
+  return <div className="flex justify-between text-gray-700 dark:text-gray-300"><span>{label}</span><span>{value}</span></div>;
+}
+
+// `wide` switches to the booking flow's two-column width and hands card styling to the
+// columns themselves; the narrow single-card form still carries the loading/error states.
+function Shell({ children, wide = false }: { children: React.ReactNode; wide?: boolean }) {
+  return (
+    <div className="min-h-screen bg-gray-50 dark:bg-gray-900 py-6">
+      <div className="container mx-auto px-4">
+        {wide ? (
+          <div className="max-w-6xl mx-auto">{children}</div>
+        ) : (
+          <div className="max-w-3xl mx-auto bg-white dark:bg-gray-800 rounded-2xl p-6 border border-gray-200 dark:border-gray-700">
+            {children}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export default function ReschedulePage() {
+  return (
+    <Suspense fallback={<Shell><Loader2 className="w-6 h-6 animate-spin text-primary" /></Shell>}>
+      <ReschedulePageContent />
+    </Suspense>
+  );
+}
diff --git a/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
index bb4e2cf12..3b6a17bb8 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/search/page.tsx
@@ -23,6 +23,10 @@ import {
 } from "lucide-react";
 import { useEffect, useRef, useState, useCallback, useMemo } from "react";
 import ModernDatePicker from "@/components/ModernDatePicker";
+import StationDropdown, {
+  pushRecentStation,
+  readRecentStationIds,
+} from "@/components/StationDropdown";
 
 const AVAILABLE_DATES_RANGE_DAYS = 90;
 
@@ -393,163 +397,6 @@ function PassengerModal({
   );
 }
 
-// ─── Station Autocomplete (Desktop dropdown) ──────────────────────────────────
-function StationDropdown({
-  stations,
-  value,
-  excludeId,
-  placeholder,
-  onSelect,
-  error,
-  recentIds,
-  onOpen,
-}: {
-  stations: Station[];
-  value: string;
-  excludeId?: string;
-  placeholder: string;
-  onSelect: (s: Station) => void;
-  error?: string;
-  recentIds: string[];
-  onOpen?: () => void;
-}) {
-  const [query, setQuery] = useState("");
-  const [open, setOpen] = useState(false);
-  const ref = useRef<HTMLDivElement>(null);
-  const inputRef = useRef<HTMLInputElement>(null);
-  const selectedStation = stations.find((s) => s.id === value);
-
-  useEffect(() => {
-    if (selectedStation && !open) setQuery("");
-  }, [selectedStation, open]);
-
-  useEffect(() => {
-    const handler = (e: MouseEvent) => {
-      if (ref.current && !ref.current.contains(e.target as Node))
-        setOpen(false);
-    };
-    document.addEventListener("mousedown", handler);
-    return () => document.removeEventListener("mousedown", handler);
-  }, []);
-
-  const filtered = query.trim()
-    ? stations.filter(
-        (s) =>
-          s.id !== excludeId &&
-          (s.name.toLowerCase().includes(query.toLowerCase()) ||
-            s.code?.toLowerCase().includes(query.toLowerCase())),
-      )
-    : stations.filter((s) => s.id !== excludeId).slice(0, 20);
-
-  const displayValue = open ? query : (selectedStation?.name ?? "");
-
-  return (
-    <div ref={ref} className="relative">
-      <div
-        className={`relative flex items-center border-2 rounded-xl transition-all duration-200 bg-white dark:bg-gray-800 ${
-          error
-            ? "border-red-400"
-            : open
-              ? "border-primary ring-2 ring-primary/20"
-              : "border-gray-200 dark:border-gray-700 hover:border-gray-300 dark:hover:border-gray-600"
-        }`}
-      >
-        <MapPin className="absolute left-3.5 w-4 h-4 text-primary flex-shrink-0" />
-        <input
-          ref={inputRef}
-          value={displayValue}
-          onChange={(e) => {
-            setQuery(e.target.value);
-            setOpen(true);
-          }}
-          onFocus={() => {
-            setQuery("");
-            setOpen(true);
-            onOpen?.();
-          }}
-          placeholder={placeholder}
-          className="w-full pl-10 pr-8 py-3.5 bg-transparent rounded-xl focus:outline-none text-sm text-gray-900 dark:text-white placeholder-gray-400"
-        />
-        {value && (
-          <button
-            type="button"
-            onClick={() => {
-              onSelect({ id: "", name: "", code: "", country: "" });
-              setQuery("");
-            }}
-            className="absolute right-3 p-0.5"
-          >
-            <X className="w-3.5 h-3.5 text-gray-400 hover:text-gray-600" />
-          </button>
-        )}
-      </div>
-
-      {open && (
-        <div className="absolute top-full left-0 right-0 mt-2 bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-xl shadow-xl z-[200] max-h-96 overflow-y-auto overflow-x-hidden scrollbar-hide">
-          {!query && recentIds.length > 0 && (
-            <div className="px-3 pt-2 pb-1">
-              <p className="text-[10px] font-semibold text-gray-400 uppercase tracking-wide mb-1">
-                Recent
-              </p>
-              {recentIds
-                .map((id) => stations.find((s) => s.id === id))
-                .filter(Boolean)
-                .map((s) => (
-                  <button
-                    key={s!.id}
-                    type="button"
-                    onMouseDown={() => {
-                      onSelect(s!);
-                      setOpen(false);
-                      setQuery("");
-                    }}
-                    className="w-full flex items-center gap-2 px-2 py-2 rounded-lg hover:bg-gray-50 dark:hover:bg-gray-700 text-left"
-                  >
-                    <Clock className="w-3.5 h-3.5 text-primary flex-shrink-0" />
-                    <span className="text-sm text-gray-800 dark:text-gray-200">
-                      {s!.name}
-                    </span>
-                  </button>
-                ))}
-              <div className="border-t border-gray-100 dark:border-gray-700 mt-1 mb-1" />
-            </div>
-          )}
-          {filtered.length === 0 ? (
-            <p className="text-sm text-gray-400 text-center py-4">
-              No stations found
-            </p>
-          ) : (
-            filtered.map((s) => (
-              <button
-                key={s.id}
-                type="button"
-                onMouseDown={() => {
-                  onSelect(s);
-                  setOpen(false);
-                  setQuery("");
-                }}
-                className="w-full flex items-center gap-2 px-3 py-2.5 hover:bg-gray-50 dark:hover:bg-gray-700 text-left transition-colors"
-              >
-                <MapPin className="w-3.5 h-3.5 text-primary flex-shrink-0" />
-                <div>
-                  <span className="text-sm font-medium text-gray-900 dark:text-white">
-                    {s.name}
-                  </span>
-                  {s.code && (
-                    <span className="text-xs text-gray-400 ml-1.5">
-                      {s.code}
-                    </span>
-                  )}
-                </div>
-              </button>
-            ))
-          )}
-        </div>
-      )}
-    </div>
-  );
-}
-
 // ─── Main Page ────────────────────────────────────────────────────────────────
 export default function SearchPage() {
   const router = useRouter();
@@ -581,13 +428,9 @@ export default function SearchPage() {
   useEffect(() => {
     router.prefetch("/booking/results");
   }, [router]);
-  const [recentStationIds, setRecentStationIds] = useState<string[]>(() => {
-    try {
-      return JSON.parse(localStorage.getItem("edr_recent_stations") || "[]");
-    } catch {
-      return [];
-    }
-  });
+  const [recentStationIds, setRecentStationIds] = useState<string[]>(
+    readRecentStationIds,
+  );
   const passengerRef = useRef<HTMLDivElement>(null);
   const widgetRef = useRef<HTMLDivElement>(null);
 
@@ -847,11 +690,7 @@ export default function SearchPage() {
   }, [noReturnRouteForPair, returnDate, setValue, clearErrors]);
 
   const saveRecent = useCallback((id: string) => {
-    setRecentStationIds((prev) => {
-      const next = [id, ...prev.filter((x) => x !== id)].slice(0, 5);
-      localStorage.setItem("edr_recent_stations", JSON.stringify(next));
-      return next;
-    });
+    setRecentStationIds((prev) => pushRecentStation(id, prev));
   }, []);
 
   const handleSwap = () => {
diff --git a/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx b/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx
index fa1a86524..e457c7d62 100644
--- a/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx
+++ b/apps/edr-passenger-web/portal/src/app/booking/seats/page.tsx
@@ -6,157 +6,18 @@ import { useRouter } from "next/navigation";
 import { useBookingStore } from "@/lib/booking-store";
 import { useQuery, useMutation } from "@tanstack/react-query";
 import { apiClient } from "@/lib/api-client";
-import { useState, useEffect, useCallback, useMemo, useRef, memo } from "react";
-import { Armchair, Bed, ChevronLeft, ChevronDown, Train, TrainFront, X } from "lucide-react";
-import Image from "next/image";
+import { useState, useEffect, useCallback, useMemo, useRef } from "react";
+import { ChevronLeft, ChevronDown, Train, TrainFront, X } from "lucide-react";
 
 import CustomModal from "@/components/CustomModal";
 import { Skeleton } from "@/components/Skeleton";
 import { isChild } from "@/utils/fare-utils";
-
-const BED_POSITION_SUFFIX: Record<string, string> = { lower: 'L', middle: 'M', upper: 'U' };
-
-const buildSeatLabel = (seat: any): string => {
-  const base: string = seat.number || seat.label || seat.seatNumber || '';
-  if (!base) return '';
-  const suffix = seat.bedPosition ? (BED_POSITION_SUFFIX[seat.bedPosition] ?? '') : '';
-  return suffix ? `${base}${suffix}` : base;
-};
-
-const BedCard = memo(({ bed, isSelected, isAssignedToOther, onToggle }: any) => {
-  const seatLabel = bed.label || bed.seatNumber || bed.number || "?";
-  const bedPosition = bed.bedPosition || "";
-  const bedType =
-    bedPosition === "upper"
-      ? "Upper"
-      : bedPosition === "middle"
-        ? "Middle"
-        : "Lower";
-  const isDisabled = bed.status !== "AVAILABLE" || isAssignedToOther;
-
-  return (
-    <button
-      onClick={() => onToggle(bed.id)}
-      disabled={isDisabled}
-      title={
-        isAssignedToOther
-          ? `Bed ${seatLabel} - already assigned to another passenger`
-          : `${bedType} Berth ${seatLabel} - ${bed.status}`
-      }
-      className={`relative flex flex-col items-center justify-center gap-0.5 w-16 sm:w-[4.5rem] py-2.5 rounded-xl border shadow-sm transition-all duration-150 ${
-        isDisabled ? "" : "hover:shadow-md hover:-translate-y-0.5 active:translate-y-0 active:scale-95"
-      } ${
-        isSelected
-          ? "bg-blue-50 border-2 border-blue-500 shadow-blue-200/60 dark:bg-blue-900/30 dark:border-blue-400 dark:shadow-none scale-[1.03]"
-          : isAssignedToOther
-            ? "bg-purple-50 border-purple-300 cursor-not-allowed dark:bg-purple-900/20 dark:border-purple-700"
-            : bed.status === "AVAILABLE"
-              ? "bg-green-50 border-green-300 hover:bg-green-100 hover:border-green-400 dark:bg-green-900/20 dark:border-green-700"
-              : bed.status === "BOOKED" || bed.status === "BLOCKED"
-                ? "bg-red-50 border-red-300 cursor-not-allowed dark:bg-red-900/20 dark:border-red-700"
-                : "bg-gray-100 border-gray-300 cursor-not-allowed dark:bg-gray-800 dark:border-gray-700"
-      }`}
-    >
-      {/* bed.png is a portrait (headboard-to-footboard) silhouette; rotate it so the
-          berth lies horizontally, matching the direction beds actually run in the coach. */}
-      <div className="w-9 h-6 flex items-center justify-center overflow-visible">
-        <Image src="/bed.png" alt="bed" width={22} height={36} className="object-contain rotate-90" />
-      </div>
-      <div className="text-xs font-bold text-gray-900 dark:text-white">
-        {seatLabel}
-      </div>
-      <div className="text-[10px] font-medium text-gray-500 dark:text-gray-400">
-        {bedType}
-      </div>
-    </button>
-  );
-});
-
-BedCard.displayName = "BedCard";
-
-// A real berth ladder is a single fixed rail mounted at the end of the bay that a
-// passenger climbs to reach every level — not a separate rung floating between each
-// pair of beds. So this renders once per bay, right after the last berth card, with
-// solid rounded rails/rungs (like a real metal ladder) rather than thin decorative lines.
-const LadderConnector = memo(() => (
-  <div
-    className="flex flex-col items-center justify-center flex-shrink-0 self-stretch w-6 sm:w-7 py-1.5"
-    title="Ladder to the middle & upper berths"
-    aria-hidden="true"
-  >
-    <svg width="100%" height="100%" viewBox="0 0 24 90" preserveAspectRatio="none" className="text-gray-400 dark:text-gray-500 drop-shadow-sm">
-      {/* Side rails */}
-      <rect x="2" y="0" width="3.5" height="90" rx="1.75" fill="currentColor" />
-      <rect x="18.5" y="0" width="3.5" height="90" rx="1.75" fill="currentColor" />
-      {/* Rungs, evenly spaced top (upper) to bottom (lower) */}
-      <rect x="2" y="6" width="20" height="4" rx="2" fill="currentColor" />
-      <rect x="2" y="30" width="20" height="4" rx="2" fill="currentColor" />
-      <rect x="2" y="54" width="20" height="4" rx="2" fill="currentColor" />
-      <rect x="2" y="78" width="20" height="4" rx="2" fill="currentColor" />
-    </svg>
-  </div>
-));
-
-LadderConnector.displayName = "LadderConnector";
-
-const SeatButton = memo(
-  ({
-    seat,
-    isSelected,
-    isAssignedToOther,
-    onToggle,
-    isBedCoach,
-    bedLabel,
-    coachSeatClass,
-  }: any) => {
-    const seatLabel = seat.number || seat.label || seat.seatNumber || "?";
-    const bedWidth = "w-24";
-    const width = isBedCoach ? bedWidth : "w-10";
-    const isDisabled = seat.status !== "AVAILABLE" || isAssignedToOther;
-
-    return (
-      <div className="flex flex-col items-center">
-        <button
-          onClick={() => onToggle(seat.id)}
-          disabled={isDisabled}
-          className={`${width} h-11 rounded flex items-center justify-center transition-all ${
-            isSelected
-              ? "bg-[rgb(20_113_76)] text-white shadow-md scale-105"
-              : isAssignedToOther
-                ? "bg-purple-400 text-white cursor-not-allowed opacity-75"
-                : seat.status === "AVAILABLE"
-                  ? "bg-green-500 hover:bg-green-600 text-white cursor-pointer hover:shadow-md"
-                  : seat.status === "HELD"
-                    ? "bg-yellow-500 text-white cursor-not-allowed opacity-75"
-                    : "bg-gray-500 text-white cursor-not-allowed opacity-60"
-          }`}
-          title={
-            isAssignedToOther
-              ? `Seat ${seatLabel}${bedLabel} - already assigned to another passenger`
-              : `Seat ${seatLabel}${bedLabel} - ${seat.status} - ${coachSeatClass}`
-          }
-          style={
-            isBedCoach
-              ? seat.row % 2 === 1
-                ? { transform: "scaleY(-1)" }
-                : undefined
-              : seat.row % 2 === 0
-                ? { transform: "scaleY(-1)" }
-                : undefined
-          }
-        >
-          {isBedCoach ? (
-            <Bed className="w-7 h-7" />
-          ) : (
-            <Armchair className="w-7 h-7" />
-          )}
-        </button>
-      </div>
-    );
-  },
-);
-
-SeatButton.displayName = "SeatButton";
+import {
+  buildSeatLabel,
+  CoachSeatLayout,
+  getBedPosition,
+  getValidSeatsForCoach as getValidSeatsForCoachData,
+} from "@/components/SeatMap";
 
 export default function SeatsPage() {
   const router = useRouter();
@@ -701,72 +562,11 @@ export default function SeatsPage() {
     [filteredCoaches, selectedCoach],
   );
 
-  const getBedPosition = (selectedClass: string): string | null => {
-    const lowerClass = selectedClass.toLowerCase();
-    if (lowerClass.includes("upper")) return "upper";
-    if (lowerClass.includes("middle")) return "middle";
-    if (lowerClass.includes("lower")) return "lower";
-    return null;
-  };
-
-  // Extracted so it can be applied to ANY coach, not just the one currently expanded —
-  // Auto Assign needs to look across every coach of this type, not just selectedCoachData.
+  // Berth-class narrowing lives in the shared SeatMap module so the booking and reschedule
+  // flows filter beds identically; this wrapper just binds the current leg's fare class.
   const getValidSeatsForCoach = useCallback(
-    (coachData: any): any[] => {
-      if (!coachData) return [];
-
-      // If coach has rooms, extract all beds from rooms
-      if (coachData.rooms?.length > 0) {
-        const allBeds: any[] = [];
-        coachData.rooms.forEach((room: any) => {
-          if (room.beds) {
-            allBeds.push(...room.beds);
-          }
-        });
-
-        let beds = allBeds.filter((s: any) => {
-          const seatLabel = s.label || s.number || s.seatNumber || "";
-          return seatLabel && !seatLabel.startsWith("-");
-        });
-
-        const isBedCoach =
-          coachData.seatClass?.toLowerCase().includes("bed") ||
-          coachData.mode?.toLowerCase().includes("bed");
-
-        if (isBedCoach && currentSchedule?.selectedSeatClass) {
-          const selectedBedPosition = getBedPosition(
-            currentSchedule.selectedSeatClass,
-          );
-          if (selectedBedPosition) {
-            beds = beds.filter((s: any) => s.bedPosition === selectedBedPosition);
-          }
-        }
-
-        return beds;
-      }
-
-      // Fallback to old seat structure
-      let seats = (coachData.seats || []).filter((s: any) => {
-        const seatLabel = s.label || s.number || s.seatNumber || "";
-        return seatLabel && !seatLabel.startsWith("-");
-      });
-      const isBedCoach =
-        coachData.isBedCoach === true ||
-        seats.some((s: any) => s.bedPosition) ||
-        coachData.seatClass?.toLowerCase().includes("bed") ||
-        coachData.mode?.toLowerCase().includes("bed");
-
-      if (isBedCoach && currentSchedule?.selectedSeatClass) {
-        const selectedBedPosition = getBedPosition(
-          currentSchedule.selectedSeatClass,
-        );
-        if (selectedBedPosition) {
-          seats = seats.filter((s: any) => s.bedPosition === selectedBedPosition);
-        }
-      }
-
-      return seats;
-    },
+    (coachData: any): any[] =>
+      getValidSeatsForCoachData(coachData, currentSchedule?.selectedSeatClass),
     [currentSchedule?.selectedSeatClass],
   );
 
@@ -1369,355 +1169,6 @@ export default function SeatsPage() {
     }
   }, [seatEligibility, seatEligibleIndices, activePassengerIndex]);
 
-  const parseSeatArrangement = (
-    arrangement: string | null,
-    seatClasses?: string[],
-  ): number[] => {
-    if (!arrangement) return [2, 2];
-
-    // Check if this is a bed coach based on seat classes
-    const isBedCoach = seatClasses?.some((sc) =>
-      sc?.toLowerCase().includes("bed"),
-    );
-
-    if (isBedCoach) {
-      // For bed coaches, arrangement like "3+0" means 3 beds stacked vertically
-      // We want to render them as single column, so return [1]
-      const parts = arrangement
-        .split("+")
-        .map((p) => parseInt(p.trim()))
-        .filter((n) => !isNaN(n) && n > 0);
-      return parts.length > 0 ? [Math.max(...parts)] : [3];
-    }
-
-    // For regular seats, parse normally (e.g., "3+2" -> [3, 2])
-    const parts = arrangement
-      .split("+")
-      .map((p) => parseInt(p.trim()))
-      .filter((n) => !isNaN(n) && n > 0);
-    return parts.length >= 2 ? parts : parts.length === 1 ? [parts[0]] : [2, 2];
-  };
-
-  const renderCoachSeats = (coach: any, isBedCoach: boolean) => {
-    const arrangement = parseSeatArrangement(
-      coach.seatArrangement,
-      coach.seatClasses || [coach.seatClass],
-    );
-
-    if (validSeats.length === 0) {
-      return <div className="text-xs text-muted-foreground">No seats</div>;
-    }
-
-    const hasBedPositionData = validSeats.some((s: any) => s.bedPosition);
-    const seatClassStr =
-      typeof selectedCoachData?.seatClass === "string"
-        ? selectedCoachData.seatClass
-        : selectedCoachData?.seatClass?.name || "";
-
-    // Indian-sleeper-style berth bay: Lower / Middle / Upper laid out horizontally, with
-    // the single ladder that actually serves the whole bay shown once at the end.
-    const renderBerthBay = (beds: any[], keyPrefix: string) => (
-      <div className="flex items-stretch gap-2">
-        {beds.map((bed: any) => (
-          <BedCard
-            key={bed.id}
-            bed={bed}
-            isSelected={isSeatSelected(bed.id)}
-            isAssignedToOther={isSeatAssignedToOther(bed.id)}
-            onToggle={handleSeatClick}
-          />
-        ))}
-        {beds.length > 1 && <LadderConnector key={`${keyPrefix}-ladder`} />}
-      </div>
-    );
-
-    // Two-side compartment: the left bay and right bay each get their own row (berths
-    // still laid out horizontally within a row), stacked one above the other and split
-    // by a dashed aisle divider — instead of squeezing both sides into a single row.
-    const renderCompartment = (leftBay: any[], rightBay: any[], key: string) => (
-      <div
-        key={key}
-        className="bg-gray-50 dark:bg-gray-800/40 rounded-2xl p-4 border border-gray-200 dark:border-gray-700 shadow-sm"
-      >
-        <div className="flex flex-col items-center gap-3">
-          {leftBay.length > 0 && (
-            <div className="flex justify-center">{renderBerthBay(leftBay, `${key}-left`)}</div>
-          )}
-          {leftBay.length > 0 && rightBay.length > 0 && (
-            <div className="w-full border-t-2 border-dashed border-gray-300 dark:border-gray-600" />
-          )}
-          {rightBay.length > 0 && (
-            <div className="flex justify-center">{renderBerthBay(rightBay, `${key}-right`)}</div>
-          )}
-        </div>
-      </div>
-    );
-
-    // Bay position ordering + left/right side detection shared by both bed layouts below.
-    const BERTH_ORDER = ["lower", "middle", "upper"];
-    const bedSideIsLeft = (bed: any, leftColByPosition: Record<string, string>) => {
-      if (bed.position === "LEFT") return true;
-      if (bed.position === "RIGHT") return false;
-      const leftCol = leftColByPosition[bed.bedPosition];
-      return leftCol ? bed.col === leftCol : true;
-    };
-
-    // Bed coach with bed positions (Upper, Middle, Lower)
-    if (isBedCoach && hasBedPositionData) {
-      // Check if this is VIP_BED or ECONOMY_BED based on room data
-      const rooms = (coach as any).rooms || [];
-      const hasRooms = rooms.length > 0;
-
-      if (hasRooms) {
-        // Room-based layout (VIP_BED with 4 beds, ECONOMY_BED with 6 beds)
-        return (
-          <div className="space-y-6">
-            {rooms.map((room: any) => {
-              const isVipBed =
-                room.category === "VIP_BED" || room.totalBeds === 4;
-              const isEconomyBed =
-                room.category === "ECONOMY_BED" || room.totalBeds === 6;
-
-              // Sort beds by position and column
-              const sortedBeds = [...(room.beds || [])].sort((a, b) => {
-                const posOrder = { upper: 3, middle: 2, lower: 1 };
-                const posA =
-                  posOrder[a.bedPosition as keyof typeof posOrder] || 0;
-                const posB =
-                  posOrder[b.bedPosition as keyof typeof posOrder] || 0;
-                if (posA !== posB) return posA - posB;
-                return (a.col || "").localeCompare(b.col || "");
-              });
-
-              return (
-                <div
-                  key={room.room_id}
-                  className="bg-gray-50 dark:bg-gray-800/50 rounded-xl p-4 border-2 border-gray-200 dark:border-gray-700"
-                >
-                  {/* Room Header */}
-                  <div className="flex items-center justify-between mb-4 pb-2 border-b border-gray-300 dark:border-gray-600">
-                    <div>
-                      <h4 className="text-sm font-bold text-gray-900 dark:text-white">
-                        Room {room.roomNumber}
-                      </h4>
-                      <p className="text-xs text-gray-500 dark:text-gray-400">
-                        {room.category === "VIP_BED"
-                          ? "VIP BED"
-                          : room.category === "ECONOMY_BED"
-                            ? "ECONOMY BED"
-                            : room.category}
-                      </p>
-                    </div>
-                    <div className="text-xs text-gray-600 dark:text-gray-400">
-                      {room.totalBeds} beds
-                    </div>
-                  </div>
-
-                  {/* Legend */}
-                  <div className="flex flex-wrap gap-2 mb-4 text-[10px]">
-                    <div className="flex items-center gap-1">
-                      <div className="w-3 h-3 bg-green-50 border border-green-300 rounded" />
-                      <span className="text-gray-600 dark:text-gray-400">
-                        Available
-                      </span>
-                    </div>
-                    <div className="flex items-center gap-1">
-                      <div className="w-3 h-3 bg-red-50 border border-red-300 rounded" />
-                      <span className="text-gray-600 dark:text-gray-400">
-                        Booked
-                      </span>
-                    </div>
-                  </div>
-
-                  {/* VIP BED Layout — 2-tier compartment (Lower/Upper), left + right of the aisle */}
-                  {isVipBed && (() => {
-                    const lowerBeds = sortedBeds.filter((b: any) => b.bedPosition === "lower");
-                    const upperBeds = sortedBeds.filter((b: any) => b.bedPosition === "upper");
-                    const isLeft = (bed: any, idx: number) =>
-                      bed.position === "LEFT" ? true : bed.position === "RIGHT" ? false : idx % 2 === 0;
-
-                    const leftBay = [lowerBeds, upperBeds]
-                      .map((arr) => arr.find((b: any, i: number) => isLeft(b, i)))
-                      .filter(Boolean);
-                    const rightBay = [lowerBeds, upperBeds]
-                      .map((arr) => arr.find((b: any, i: number) => !isLeft(b, i)))
-                      .filter(Boolean);
-
-                    return renderCompartment(leftBay, rightBay, `${room.room_id}-vip`);
-                  })()}
-
-                  {/* ECONOMY BED Layout — 3-tier compartment (Lower/Middle/Upper), left + right of the aisle */}
-                  {isEconomyBed && (() => {
-                    const leftColByPosition: Record<string, string> = { lower: "A", middle: "B", upper: "C" };
-                    const leftBay = BERTH_ORDER
-                      .map((pos) => sortedBeds.find((b: any) => b.bedPosition === pos && bedSideIsLeft(b, leftColByPosition)))
-                      .filter(Boolean);
-                    const rightBay = BERTH_ORDER
-                      .map((pos) => sortedBeds.find((b: any) => b.bedPosition === pos && !bedSideIsLeft(b, leftColByPosition)))
-                      .filter(Boolean);
-
-                    return renderCompartment(leftBay, rightBay, `${room.room_id}-eco`);
-                  })()}
-                </div>
-              );
-            })}
-          </div>
-        );
-      }
-
-      // Fallback: beds without room data — group into numbered bays (Lower/Middle/Upper),
-      // then pair adjacent bays into two-side compartments, same as the room-based layouts.
-      const seatGroups = new Map<string, any[]>();
-
-      for (const seat of validSeats) {
-        const baseNumber = seat.seatNumber || seat.number || seat.label || "";
-        if (!seatGroups.has(baseNumber)) {
-          seatGroups.set(baseNumber, []);
-        }
-        seatGroups.get(baseNumber)!.push(seat);
-      }
-
-      const sortedGroups = Array.from(seatGroups.entries()).sort(([a], [b]) => {
-        const numA = parseInt(a) || 0;
-        const numB = parseInt(b) || 0;
-        return numA - numB;
-      });
-
-      const bays = sortedGroups
-        .map(([, beds]) =>
-          BERTH_ORDER.map((pos) => beds.find((seat: any) => seat.bedPosition === pos)).filter(Boolean),
-        )
-        .filter((bay) => bay.length > 0);
-
-      return (
-        <div className="space-y-4">
-          {Array.from({ length: Math.ceil(bays.length / 2) }, (_, i) => {
-            const leftBay = bays[i * 2] || [];
-            const rightBay = bays[i * 2 + 1] || [];
-            return renderCompartment(leftBay, rightBay, `bay-compartment-${i}`);
-          })}
-        </div>
-      );
-    }
-
-    // Regular seats with row/column arrangement
-    const rowMap = new Map<number, any[]>();
-    for (const seat of validSeats) {
-      if (!rowMap.has(seat.row)) {
-        rowMap.set(seat.row, []);
-      }
-      rowMap.get(seat.row)!.push(seat);
-    }
-
-    const rows = Array.from(rowMap.entries())
-      .sort(([a], [b]) => a - b)
-      .map(([_, seats]) => seats.sort((a, b) => a.col.localeCompare(b.col)));
-
-    return (
-      <div className="space-y-0">
-        {rows.map((rowSeats: any[], rowIdx: number) => {
-          const groups: any[][] = [];
-
-          // Split seats into groups based on arrangement
-          if (arrangement.length === 1) {
-            // Single group (all seats together)
-            groups.push(rowSeats);
-          } else {
-            // Multiple groups with aisle separation
-            arrangement.forEach((_groupSize, groupIdx) => {
-              const startIdx = arrangement
-                .slice(0, groupIdx)
-                .reduce((sum, size) => sum + size, 0);
-              const endIdx = arrangement
-                .slice(0, groupIdx + 1)
-                .reduce((sum, size) => sum + size, 0);
-              const currentGroup = rowSeats.slice(startIdx, endIdx);
-              if (currentGroup.length > 0) groups.push(currentGroup);
-            });
-          }
-
-          const rowNumber = rowSeats[0]?.row || 1;
-          const shouldFlipArmchair = rowNumber % 2 === 0;
-          const showSpacing = rowIdx % 2 === 1;
-
-          return (
-            <div key={`row-${rowNumber}-${rowSeats[0]?.id}`}>
-              {shouldFlipArmchair && (
-                <div className="flex gap-3 justify-start text-xs text-muted-foreground mb-1">
-                  {groups.map((group, gIdx) => (
-                    <div
-                      key={`num-before-group-${gIdx}`}
-                      className="flex gap-0.5"
-                    >
-                      {group.map((seat: any) => {
-                        const seatLabel =
-                          seat.label || seat.number || seat.seatNumber || "";
-                        return (
-                          <div
-                            key={`num-${seat.id}`}
-                            className="w-10 h-4 flex items-center justify-center text-xs font-bold leading-3 text-foreground"
-                          >
-                            {seatLabel}
-                          </div>
-                        );
-                      })}
-                    </div>
-                  ))}
-                </div>
-              )}
-              <div className="flex gap-3 justify-start">
-                {groups.map((group, gIdx) => (
-                  <div key={`group-${gIdx}`} className="flex gap-0.5">
-                    {group.map((seat: any) => (
-                      <SeatButton
-                        key={seat.id}
-                        seat={seat}
-                        isSelected={isSeatSelected(seat.id)}
-                        isAssignedToOther={isSeatAssignedToOther(seat.id)}
-                        onToggle={handleSeatClick}
-                        isBedCoach={false}
-                        bedLabel=""
-                        coachSeatClass={seatClassStr}
-                      />
-                    ))}
-                  </div>
-                ))}
-              </div>
-
-              {!shouldFlipArmchair && (
-                <div className="flex gap-3 justify-start text-xs text-muted-foreground mb-1">
-                  {groups.map((group, gIdx) => (
-                    <div
-                      key={`num-after-group-${gIdx}`}
-                      className="flex gap-0.5"
-                    >
-                      {group.map((seat: any) => {
-                        const seatLabel =
-                          seat.label || seat.number || seat.seatNumber || "";
-                        return (
-                          <div
-                            key={`num-${seat.id}`}
-                            className="w-10 h-4 flex items-center justify-center text-xs font-bold leading-3 text-foreground"
-                          >
-                            {seatLabel}
-                          </div>
-                        );
-                      })}
-                    </div>
-                  ))}
-                </div>
-              )}
-
-              {showSpacing && (
-                <div className="h-3 border-b border-gray-200 dark:border-gray-700" />
-              )}
-            </div>
-          );
-        })}
-      </div>
-    );
-  };
-
   if (
     isRoundTrip
       ? !outboundSchedule || (!isPackageBooking && !inboundSchedule) || !passengers.length
@@ -2414,7 +1865,14 @@ export default function SeatsPage() {
                                         No seats in this coach
                                       </p>
                                     ) : (
-                                      renderCoachSeats(selectedCoachData, isBedCoach)
+                                      <CoachSeatLayout
+                                        coach={selectedCoachData}
+                                        isBedCoach={isBedCoach}
+                                        seats={validSeats}
+                                        isSeatSelected={isSeatSelected}
+                                        isSeatAssignedToOther={isSeatAssignedToOther}
+                                        onSeatToggle={handleSeatClick}
+                                      />
                                     )}
                                   </div>
                                 </div>
diff --git a/apps/edr-passenger-web/portal/src/components/SeatMap.tsx b/apps/edr-passenger-web/portal/src/components/SeatMap.tsx
new file mode 100644
index 000000000..94fbe7c98
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/components/SeatMap.tsx
@@ -0,0 +1,706 @@
+"use client";
+
+import { memo } from "react";
+import Image from "next/image";
+import { Armchair, Bed } from "lucide-react";
+
+/**
+ * The seat map shared by the booking flow (`/booking/seats`) and the reschedule flow
+ * (`/booking/reschedule`). Everything here is presentational: it takes a coach from
+ * `GET /seats/seatmap/:scheduleId` and three callbacks, and knows nothing about bookings,
+ * passengers, holds or fares. Both pages must render seats identically, so this is the one
+ * copy — extend it rather than forking a second layout.
+ */
+
+export const BED_POSITION_SUFFIX: Record<string, string> = {
+  lower: "L",
+  middle: "M",
+  upper: "U",
+};
+
+export const buildSeatLabel = (seat: any): string => {
+  const base: string = seat.number || seat.label || seat.seatNumber || "";
+  if (!base) return "";
+  const suffix = seat.bedPosition ? (BED_POSITION_SUFFIX[seat.bedPosition] ?? "") : "";
+  return suffix ? `${base}${suffix}` : base;
+};
+
+/** "Economy Bed - Upper" → "upper". Null when the class names no berth level. */
+export const getBedPosition = (selectedClass: string): string | null => {
+  const lowerClass = selectedClass.toLowerCase();
+  if (lowerClass.includes("upper")) return "upper";
+  if (lowerClass.includes("middle")) return "middle";
+  if (lowerClass.includes("lower")) return "lower";
+  return null;
+};
+
+export const isBedCoachData = (coachData: any): boolean =>
+  coachData?.isBedCoach === true ||
+  coachData?.rooms?.length > 0 ||
+  (coachData?.seats || []).some((s: any) => s.bedPosition) ||
+  coachData?.seatClass?.toLowerCase().includes("bed") ||
+  coachData?.mode?.toLowerCase().includes("bed");
+
+/**
+ * Flattens a coach into the seats that are actually selectable: beds out of `rooms` when the
+ * coach has them, otherwise `seats`. Placeholder rows (labels starting "-") are dropped, and
+ * on a bed coach a berth-specific fare class narrows the list to that level.
+ */
+export const getValidSeatsForCoach = (
+  coachData: any,
+  selectedSeatClass?: string | null,
+): any[] => {
+  if (!coachData) return [];
+
+  if (coachData.rooms?.length > 0) {
+    const allBeds: any[] = [];
+    coachData.rooms.forEach((room: any) => {
+      if (room.beds) allBeds.push(...room.beds);
+    });
+
+    let beds = allBeds.filter((s: any) => {
+      const seatLabel = s.label || s.number || s.seatNumber || "";
+      return seatLabel && !seatLabel.startsWith("-");
+    });
+
+    if (isBedCoachData(coachData) && selectedSeatClass) {
+      const selectedBedPosition = getBedPosition(selectedSeatClass);
+      if (selectedBedPosition) {
+        beds = beds.filter((s: any) => s.bedPosition === selectedBedPosition);
+      }
+    }
+    return beds;
+  }
+
+  let seats = (coachData.seats || []).filter((s: any) => {
+    const seatLabel = s.label || s.number || s.seatNumber || "";
+    return seatLabel && !seatLabel.startsWith("-");
+  });
+
+  if (isBedCoachData(coachData) && selectedSeatClass) {
+    const selectedBedPosition = getBedPosition(selectedSeatClass);
+    if (selectedBedPosition) {
+      seats = seats.filter((s: any) => s.bedPosition === selectedBedPosition);
+    }
+  }
+  return seats;
+};
+
+/** "3+2" → [3, 2] so the aisle gap lands between the groups. Bed coaches collapse to one column. */
+export const parseSeatArrangement = (
+  arrangement: string | null,
+  seatClasses?: (string | undefined)[],
+): number[] => {
+  if (!arrangement) return [2, 2];
+
+  const isBedCoach = seatClasses?.some((sc) => sc?.toLowerCase().includes("bed"));
+
+  if (isBedCoach) {
+    // For bed coaches, arrangement like "3+0" means 3 beds stacked vertically —
+    // render them as a single column.
+    const parts = arrangement
+      .split("+")
+      .map((p) => parseInt(p.trim()))
+      .filter((n) => !isNaN(n) && n > 0);
+    return parts.length > 0 ? [Math.max(...parts)] : [3];
+  }
+
+  const parts = arrangement
+    .split("+")
+    .map((p) => parseInt(p.trim()))
+    .filter((n) => !isNaN(n) && n > 0);
+  return parts.length >= 2 ? parts : parts.length === 1 ? [parts[0]] : [2, 2];
+};
+
+export const BedCard = memo(({ bed, isSelected, isAssignedToOther, onToggle }: any) => {
+  const seatLabel = bed.label || bed.seatNumber || bed.number || "?";
+  const bedPosition = bed.bedPosition || "";
+  const bedType =
+    bedPosition === "upper" ? "Upper" : bedPosition === "middle" ? "Middle" : "Lower";
+  const isDisabled = bed.status !== "AVAILABLE" || isAssignedToOther;
+
+  return (
+    <button
+      onClick={() => onToggle(bed.id)}
+      disabled={isDisabled}
+      title={
+        isAssignedToOther
+          ? `Bed ${seatLabel} - already assigned to another passenger`
+          : `${bedType} Berth ${seatLabel} - ${bed.status}`
+      }
+      className={`relative flex flex-col items-center justify-center gap-0.5 w-16 sm:w-[4.5rem] py-2.5 rounded-xl border shadow-sm transition-all duration-150 ${
+        isDisabled ? "" : "hover:shadow-md hover:-translate-y-0.5 active:translate-y-0 active:scale-95"
+      } ${
+        isSelected
+          ? "bg-blue-50 border-2 border-blue-500 shadow-blue-200/60 dark:bg-blue-900/30 dark:border-blue-400 dark:shadow-none scale-[1.03]"
+          : isAssignedToOther
+            ? "bg-purple-50 border-purple-300 cursor-not-allowed dark:bg-purple-900/20 dark:border-purple-700"
+            : bed.status === "AVAILABLE"
+              ? "bg-green-50 border-green-300 hover:bg-green-100 hover:border-green-400 dark:bg-green-900/20 dark:border-green-700"
+              : bed.status === "BOOKED" || bed.status === "BLOCKED"
+                ? "bg-red-50 border-red-300 cursor-not-allowed dark:bg-red-900/20 dark:border-red-700"
+                : "bg-gray-100 border-gray-300 cursor-not-allowed dark:bg-gray-800 dark:border-gray-700"
+      }`}
+    >
+      {/* bed.png is a portrait (headboard-to-footboard) silhouette; rotate it so the
+          berth lies horizontally, matching the direction beds actually run in the coach. */}
+      <div className="w-9 h-6 flex items-center justify-center overflow-visible">
+        <Image src="/bed.png" alt="bed" width={22} height={36} className="object-contain rotate-90" />
+      </div>
+      <div className="text-xs font-bold text-gray-900 dark:text-white">{seatLabel}</div>
+      <div className="text-[10px] font-medium text-gray-500 dark:text-gray-400">{bedType}</div>
+    </button>
+  );
+});
+
+BedCard.displayName = "BedCard";
+
+// A real berth ladder is a single fixed rail mounted at the end of the bay that a
+// passenger climbs to reach every level — not a separate rung floating between each
+// pair of beds. So this renders once per bay, right after the last berth card, with
+// solid rounded rails/rungs (like a real metal ladder) rather than thin decorative lines.
+export const LadderConnector = memo(() => (
+  <div
+    className="flex flex-col items-center justify-center flex-shrink-0 self-stretch w-6 sm:w-7 py-1.5"
+    title="Ladder to the middle & upper berths"
+    aria-hidden="true"
+  >
+    <svg width="100%" height="100%" viewBox="0 0 24 90" preserveAspectRatio="none" className="text-gray-400 dark:text-gray-500 drop-shadow-sm">
+      {/* Side rails */}
+      <rect x="2" y="0" width="3.5" height="90" rx="1.75" fill="currentColor" />
+      <rect x="18.5" y="0" width="3.5" height="90" rx="1.75" fill="currentColor" />
+      {/* Rungs, evenly spaced top (upper) to bottom (lower) */}
+      <rect x="2" y="6" width="20" height="4" rx="2" fill="currentColor" />
+      <rect x="2" y="30" width="20" height="4" rx="2" fill="currentColor" />
+      <rect x="2" y="54" width="20" height="4" rx="2" fill="currentColor" />
+      <rect x="2" y="78" width="20" height="4" rx="2" fill="currentColor" />
+    </svg>
+  </div>
+));
+
+LadderConnector.displayName = "LadderConnector";
+
+export const SeatButton = memo(
+  ({ seat, isSelected, isAssignedToOther, onToggle, isBedCoach, bedLabel, coachSeatClass }: any) => {
+    const seatLabel = seat.number || seat.label || seat.seatNumber || "?";
+    const bedWidth = "w-24";
+    const width = isBedCoach ? bedWidth : "w-10";
+    const isDisabled = seat.status !== "AVAILABLE" || isAssignedToOther;
+
+    return (
+      <div className="flex flex-col items-center">
+        <button
+          onClick={() => onToggle(seat.id)}
+          disabled={isDisabled}
+          className={`${width} h-11 rounded flex items-center justify-center transition-all ${
+            isSelected
+              ? "bg-[rgb(20_113_76)] text-white shadow-md scale-105"
+              : isAssignedToOther
+                ? "bg-purple-400 text-white cursor-not-allowed opacity-75"
+                : seat.status === "AVAILABLE"
+                  ? "bg-green-500 hover:bg-green-600 text-white cursor-pointer hover:shadow-md"
+                  : seat.status === "HELD"
+                    ? "bg-yellow-500 text-white cursor-not-allowed opacity-75"
+                    : "bg-gray-500 text-white cursor-not-allowed opacity-60"
+          }`}
+          title={
+            isAssignedToOther
+              ? `Seat ${seatLabel}${bedLabel} - already assigned to another passenger`
+              : `Seat ${seatLabel}${bedLabel} - ${seat.status} - ${coachSeatClass}`
+          }
+          style={
+            isBedCoach
+              ? seat.row % 2 === 1
+                ? { transform: "scaleY(-1)" }
+                : undefined
+              : seat.row % 2 === 0
+                ? { transform: "scaleY(-1)" }
+                : undefined
+          }
+        >
+          {isBedCoach ? <Bed className="w-7 h-7" /> : <Armchair className="w-7 h-7" />}
+        </button>
+      </div>
+    );
+  },
+);
+
+SeatButton.displayName = "SeatButton";
+
+/** Available / Selected / Booked swatches, shown above every expanded coach. */
+export function SeatLegend() {
+  return (
+    <div className="flex flex-wrap gap-3 mb-4">
+      {[
+        { color: "bg-green-50 border border-green-300", label: "Available" },
+        { color: "bg-blue-50 border-2 border-blue-500", label: "Selected" },
+        { color: "bg-red-50 border border-red-300", label: "Booked" },
+      ].map(({ color, label }) => (
+        <div key={label} className="flex items-center gap-1.5">
+          <div className={`w-4 h-4 ${color} rounded`} />
+          <span className="text-xs text-gray-600 dark:text-gray-400">{label}</span>
+        </div>
+      ))}
+    </div>
+  );
+}
+
+export interface CoachSeatLayoutProps {
+  coach: any;
+  isBedCoach: boolean;
+  /** Already filtered by `getValidSeatsForCoach` — the caller owns berth-class narrowing. */
+  seats: any[];
+  isSeatSelected: (seatId: string) => boolean;
+  isSeatAssignedToOther: (seatId: string) => boolean;
+  onSeatToggle: (seatId: string) => void;
+}
+
+/**
+ * The seat grid for one coach. Four layouts, picked off the coach's own shape:
+ * room-based VIP (4 berths), room-based Economy (6 berths), room-less berth bays, and
+ * regular rows with the aisle gap from `seatArrangement`.
+ */
+export function CoachSeatLayout({
+  coach,
+  isBedCoach,
+  seats: validSeats,
+  isSeatSelected,
+  isSeatAssignedToOther,
+  onSeatToggle,
+}: CoachSeatLayoutProps) {
+  const arrangement = parseSeatArrangement(
+    coach?.seatArrangement,
+    coach?.seatClasses || [coach?.seatClass],
+  );
+
+  if (validSeats.length === 0) {
+    return <div className="text-xs text-muted-foreground">No seats</div>;
+  }
+
+  const hasBedPositionData = validSeats.some((s: any) => s.bedPosition);
+  const seatClassStr =
+    typeof coach?.seatClass === "string" ? coach.seatClass : coach?.seatClass?.name || "";
+
+  // Indian-sleeper-style berth bay: Lower / Middle / Upper laid out horizontally, with
+  // the single ladder that actually serves the whole bay shown once at the end.
+  const renderBerthBay = (beds: any[], keyPrefix: string) => (
+    <div className="flex items-stretch gap-2">
+      {beds.map((bed: any) => (
+        <BedCard
+          key={bed.id}
+          bed={bed}
+          isSelected={isSeatSelected(bed.id)}
+          isAssignedToOther={isSeatAssignedToOther(bed.id)}
+          onToggle={onSeatToggle}
+        />
+      ))}
+      {beds.length > 1 && <LadderConnector key={`${keyPrefix}-ladder`} />}
+    </div>
+  );
+
+  // Two-side compartment: the left bay and right bay each get their own row (berths
+  // still laid out horizontally within a row), stacked one above the other and split
+  // by a dashed aisle divider — instead of squeezing both sides into a single row.
+  const renderCompartment = (leftBay: any[], rightBay: any[], key: string) => (
+    <div
+      key={key}
+      className="bg-gray-50 dark:bg-gray-800/40 rounded-2xl p-4 border border-gray-200 dark:border-gray-700 shadow-sm"
+    >
+      <div className="flex flex-col items-center gap-3">
+        {leftBay.length > 0 && (
+          <div className="flex justify-center">{renderBerthBay(leftBay, `${key}-left`)}</div>
+        )}
+        {leftBay.length > 0 && rightBay.length > 0 && (
+          <div className="w-full border-t-2 border-dashed border-gray-300 dark:border-gray-600" />
+        )}
+        {rightBay.length > 0 && (
+          <div className="flex justify-center">{renderBerthBay(rightBay, `${key}-right`)}</div>
+        )}
+      </div>
+    </div>
+  );
+
+  // Bay position ordering + left/right side detection shared by both bed layouts below.
+  const BERTH_ORDER = ["lower", "middle", "upper"];
+  const bedSideIsLeft = (bed: any, leftColByPosition: Record<string, string>) => {
+    if (bed.position === "LEFT") return true;
+    if (bed.position === "RIGHT") return false;
+    const leftCol = leftColByPosition[bed.bedPosition];
+    return leftCol ? bed.col === leftCol : true;
+  };
+
+  if (isBedCoach && hasBedPositionData) {
+    const rooms = (coach as any)?.rooms || [];
+
+    if (rooms.length > 0) {
+      // Room-based layout (VIP_BED with 4 beds, ECONOMY_BED with 6 beds)
+      return (
+        <div className="space-y-6">
+          {rooms.map((room: any) => {
+            const isVipBed = room.category === "VIP_BED" || room.totalBeds === 4;
+            const isEconomyBed = room.category === "ECONOMY_BED" || room.totalBeds === 6;
+
+            const sortedBeds = [...(room.beds || [])].sort((a, b) => {
+              const posOrder = { upper: 3, middle: 2, lower: 1 };
+              const posA = posOrder[a.bedPosition as keyof typeof posOrder] || 0;
+              const posB = posOrder[b.bedPosition as keyof typeof posOrder] || 0;
+              if (posA !== posB) return posA - posB;
+              return (a.col || "").localeCompare(b.col || "");
+            });
+
+            return (
+              <div
+                key={room.room_id}
+                className="bg-gray-50 dark:bg-gray-800/50 rounded-xl p-4 border-2 border-gray-200 dark:border-gray-700"
+              >
+                {/* Room Header */}
+                <div className="flex items-center justify-between mb-4 pb-2 border-b border-gray-300 dark:border-gray-600">
+                  <div>
+                    <h4 className="text-sm font-bold text-gray-900 dark:text-white">
+                      Room {room.roomNumber}
+                    </h4>
+                    <p className="text-xs text-gray-500 dark:text-gray-400">
+                      {room.category === "VIP_BED"
+                        ? "VIP BED"
+                        : room.category === "ECONOMY_BED"
+                          ? "ECONOMY BED"
+                          : room.category}
+                    </p>
+                  </div>
+                  <div className="text-xs text-gray-600 dark:text-gray-400">
+                    {room.totalBeds} beds
+                  </div>
+                </div>
+
+                {/* Legend */}
+                <div className="flex flex-wrap gap-2 mb-4 text-[10px]">
+                  <div className="flex items-center gap-1">
+                    <div className="w-3 h-3 bg-green-50 border border-green-300 rounded" />
+                    <span className="text-gray-600 dark:text-gray-400">Available</span>
+                  </div>
+                  <div className="flex items-center gap-1">
+                    <div className="w-3 h-3 bg-red-50 border border-red-300 rounded" />
+                    <span className="text-gray-600 dark:text-gray-400">Booked</span>
+                  </div>
+                </div>
+
+                {/* VIP BED Layout — 2-tier compartment (Lower/Upper), left + right of the aisle */}
+                {isVipBed && (() => {
+                  const lowerBeds = sortedBeds.filter((b: any) => b.bedPosition === "lower");
+                  const upperBeds = sortedBeds.filter((b: any) => b.bedPosition === "upper");
+                  const isLeft = (bed: any, idx: number) =>
+                    bed.position === "LEFT" ? true : bed.position === "RIGHT" ? false : idx % 2 === 0;
+
+                  const leftBay = [lowerBeds, upperBeds]
+                    .map((arr) => arr.find((b: any, i: number) => isLeft(b, i)))
+                    .filter(Boolean);
+                  const rightBay = [lowerBeds, upperBeds]
+                    .map((arr) => arr.find((b: any, i: number) => !isLeft(b, i)))
+                    .filter(Boolean);
+
+                  return renderCompartment(leftBay, rightBay, `${room.room_id}-vip`);
+                })()}
+
+                {/* ECONOMY BED Layout — 3-tier compartment (Lower/Middle/Upper), left + right of the aisle */}
+                {isEconomyBed && (() => {
+                  const leftColByPosition: Record<string, string> = { lower: "A", middle: "B", upper: "C" };
+                  const leftBay = BERTH_ORDER
+                    .map((pos) => sortedBeds.find((b: any) => b.bedPosition === pos && bedSideIsLeft(b, leftColByPosition)))
+                    .filter(Boolean);
+                  const rightBay = BERTH_ORDER
+                    .map((pos) => sortedBeds.find((b: any) => b.bedPosition === pos && !bedSideIsLeft(b, leftColByPosition)))
+                    .filter(Boolean);
+
+                  return renderCompartment(leftBay, rightBay, `${room.room_id}-eco`);
+                })()}
+              </div>
+            );
+          })}
+        </div>
+      );
+    }
+
+    // Fallback: beds without room data — group into numbered bays (Lower/Middle/Upper),
+    // then pair adjacent bays into two-side compartments, same as the room-based layouts.
+    const seatGroups = new Map<string, any[]>();
+    for (const seat of validSeats) {
+      const baseNumber = seat.seatNumber || seat.number || seat.label || "";
+      if (!seatGroups.has(baseNumber)) seatGroups.set(baseNumber, []);
+      seatGroups.get(baseNumber)!.push(seat);
+    }
+
+    const sortedGroups = Array.from(seatGroups.entries()).sort(([a], [b]) => {
+      const numA = parseInt(a) || 0;
+      const numB = parseInt(b) || 0;
+      return numA - numB;
+    });
+
+    const bays = sortedGroups
+      .map(([, beds]) =>
+        BERTH_ORDER.map((pos) => beds.find((seat: any) => seat.bedPosition === pos)).filter(Boolean),
+      )
+      .filter((bay) => bay.length > 0);
+
+    return (
+      <div className="space-y-4">
+        {Array.from({ length: Math.ceil(bays.length / 2) }, (_, i) => {
+          const leftBay = bays[i * 2] || [];
+          const rightBay = bays[i * 2 + 1] || [];
+          return renderCompartment(leftBay, rightBay, `bay-compartment-${i}`);
+        })}
+      </div>
+    );
+  }
+
+  // Regular seats with row/column arrangement
+  const rowMap = new Map<number, any[]>();
+  for (const seat of validSeats) {
+    if (!rowMap.has(seat.row)) rowMap.set(seat.row, []);
+    rowMap.get(seat.row)!.push(seat);
+  }
+
+  const rows = Array.from(rowMap.entries())
+    .sort(([a], [b]) => a - b)
+    .map(([_, seats]) => seats.sort((a, b) => a.col.localeCompare(b.col)));
+
+  const renderSeatNumberStrip = (groups: any[][], keyPrefix: string) => (
+    <div className="flex gap-3 justify-start text-xs text-muted-foreground mb-1">
+      {groups.map((group, gIdx) => (
+        <div key={`${keyPrefix}-group-${gIdx}`} className="flex gap-0.5">
+          {group.map((seat: any) => (
+            <div
+              key={`num-${seat.id}`}
+              className="w-10 h-4 flex items-center justify-center text-xs font-bold leading-3 text-foreground"
+            >
+              {seat.label || seat.number || seat.seatNumber || ""}
+            </div>
+          ))}
+        </div>
+      ))}
+    </div>
+  );
+
+  return (
+    <div className="space-y-0">
+      {rows.map((rowSeats: any[], rowIdx: number) => {
+        const groups: any[][] = [];
+
+        if (arrangement.length === 1) {
+          groups.push(rowSeats);
+        } else {
+          arrangement.forEach((_groupSize, groupIdx) => {
+            const startIdx = arrangement.slice(0, groupIdx).reduce((sum, size) => sum + size, 0);
+            const endIdx = arrangement.slice(0, groupIdx + 1).reduce((sum, size) => sum + size, 0);
+            const currentGroup = rowSeats.slice(startIdx, endIdx);
+            if (currentGroup.length > 0) groups.push(currentGroup);
+          });
+        }
+
+        const rowNumber = rowSeats[0]?.row || 1;
+        const shouldFlipArmchair = rowNumber % 2 === 0;
+        const showSpacing = rowIdx % 2 === 1;
+
+        return (
+          <div key={`row-${rowNumber}-${rowSeats[0]?.id}`}>
+            {shouldFlipArmchair && renderSeatNumberStrip(groups, `before-${rowNumber}`)}
+
+            <div className="flex gap-3 justify-start">
+              {groups.map((group, gIdx) => (
+                <div key={`group-${gIdx}`} className="flex gap-0.5">
+                  {group.map((seat: any) => (
+                    <SeatButton
+                      key={seat.id}
+                      seat={seat}
+                      isSelected={isSeatSelected(seat.id)}
+                      isAssignedToOther={isSeatAssignedToOther(seat.id)}
+                      onToggle={onSeatToggle}
+                      isBedCoach={false}
+                      bedLabel=""
+                      coachSeatClass={seatClassStr}
+                    />
+                  ))}
+                </div>
+              ))}
+            </div>
+
+            {!shouldFlipArmchair && renderSeatNumberStrip(groups, `after-${rowNumber}`)}
+
+            {showSpacing && <div className="h-3 border-b border-gray-200 dark:border-gray-700" />}
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+export interface SeatMapProps {
+  /** Coaches straight off `GET /seats/seatmap/:scheduleId`. */
+  coaches: any[];
+  selectedCoachId: string | null;
+  onSelectCoach: (coachId: string | null) => void;
+  /** Berth-level fare class, e.g. "Economy Bed - Upper". Narrows a bed coach to one level. */
+  selectedSeatClass?: string | null;
+  isSeatSelected: (seatId: string) => boolean;
+  isSeatAssignedToOther: (seatId: string) => boolean;
+  onSeatToggle: (seatId: string) => void;
+  emptyLabel?: string;
+}
+
+/**
+ * Coach accordion + legend + seat grid, styled as the train itself: coupling joints between
+ * cars, a brand stripe top and bottom, and per-coach availability bars.
+ */
+export default function SeatMap({
+  coaches,
+  selectedCoachId,
+  onSelectCoach,
+  selectedSeatClass,
+  isSeatSelected,
+  isSeatAssignedToOther,
+  onSeatToggle,
+  emptyLabel = "No coach of your class on this train.",
+}: SeatMapProps) {
+  if (!coaches || coaches.length === 0) {
+    return <p className="text-sm text-gray-500 dark:text-gray-400">{emptyLabel}</p>;
+  }
+
+  return (
+    <div className="py-1">
+      {coaches.map((coach: any, index: number) => {
+        const coachSeats = getValidSeatsForCoach(coach, selectedSeatClass);
+        const available = coachSeats.filter((s: any) => s.status === "AVAILABLE").length;
+        const total = coachSeats.length;
+        const isExpanded = selectedCoachId === coach.id;
+        const isBedCoach = isBedCoachData(coach);
+        const coachLabel = coach.label || coach.name || coach.coachNumber || `Coach ${index + 1}`;
+
+        return (
+          <div key={coach.id}>
+            {/* Coupling joint */}
+            <div className="flex justify-center py-0.5">
+              <div className="flex flex-col items-center gap-px">
+                <div className="w-7 h-2 bg-gray-300 dark:bg-gray-600 rounded-sm" />
+                <div className="w-3 h-3 bg-gray-400 dark:bg-gray-500 rounded-sm" />
+                <div className="w-7 h-2 bg-gray-300 dark:bg-gray-600 rounded-sm" />
+              </div>
+            </div>
+
+            {/* Coach car */}
+            <div
+              className={`border-2 overflow-hidden transition-all duration-200 ${
+                isExpanded
+                  ? "border-[rgb(20,113,76)] shadow-lg shadow-[rgb(20,113,76)]/10"
+                  : "border-gray-200 dark:border-gray-700 hover:border-gray-300 dark:hover:border-gray-600"
+              }`}
+            >
+              {/* Top colour stripe — brand rail */}
+              <div
+                className={`h-1.5 transition-colors duration-200 ${
+                  isExpanded ? "bg-[rgb(20,113,76)]" : "bg-gray-200 dark:bg-gray-700"
+                }`}
+              />
+
+              <button
+                type="button"
+                onClick={() => onSelectCoach(isExpanded ? null : coach.id)}
+                className={`w-full flex items-center justify-between px-4 py-3 transition-colors ${
+                  isExpanded
+                    ? "bg-[rgb(20,113,76)]/5 dark:bg-[rgb(20,113,76)]/10"
+                    : "bg-white dark:bg-gray-800 hover:bg-gray-50 dark:hover:bg-gray-900/30"
+                }`}
+              >
+                <div className="flex items-center gap-3">
+                  <div
+                    className={`w-9 h-9 rounded-lg flex items-center justify-center flex-shrink-0 font-bold text-sm transition-colors ${
+                      isExpanded
+                        ? "bg-[rgb(20,113,76)] text-white"
+                        : "bg-gray-100 dark:bg-gray-700 text-gray-600 dark:text-gray-300"
+                    }`}
+                  >
+                    {index + 1}
+                  </div>
+                  <div className="text-left">
+                    <div
+                      className={`font-semibold text-sm ${
+                        isExpanded ? "text-[rgb(20,113,76)]" : "text-gray-900 dark:text-white"
+                      }`}
+                    >
+                      {coachLabel}
+                    </div>
+                    <div className="text-xs text-gray-500 dark:text-gray-400 mt-0.5">
+                      {available} of {total} seats available
+                    </div>
+                  </div>
+                </div>
+                <div className="flex items-center gap-3">
+                  {/* Mini availability bars */}
+                  <div className="hidden sm:flex items-end gap-0.5 h-5">
+                    {Array.from({ length: Math.min(total, 12) }).map((_, i) => (
+                      <div
+                        key={i}
+                        className={`w-1 rounded-sm transition-colors ${
+                          i < Math.round((available / Math.max(total, 1)) * Math.min(total, 12))
+                            ? "h-full bg-green-400"
+                            : "h-3 bg-gray-200 dark:bg-gray-600"
+                        }`}
+                      />
+                    ))}
+                  </div>
+                  <ChevronDownIcon isExpanded={isExpanded} />
+                </div>
+              </button>
+
+              {/* Expanded seat map */}
+              {isExpanded && (
+                <div className="border-t border-gray-100 dark:border-gray-800 bg-white dark:bg-gray-800 p-4">
+                  <SeatLegend />
+                  <div className="overflow-x-auto">
+                    <div className="inline-block bg-gray-50 dark:bg-gray-700/30 rounded-xl p-4 border border-gray-200 dark:border-gray-700">
+                      {coachSeats.length === 0 ? (
+                        <p className="text-sm text-gray-400 py-4">No seats in this coach</p>
+                      ) : (
+                        <CoachSeatLayout
+                          coach={coach}
+                          isBedCoach={isBedCoach}
+                          seats={coachSeats}
+                          isSeatSelected={isSeatSelected}
+                          isSeatAssignedToOther={isSeatAssignedToOther}
+                          onSeatToggle={onSeatToggle}
+                        />
+                      )}
+                    </div>
+                  </div>
+                </div>
+              )}
+
+              {/* Bottom colour stripe */}
+              <div
+                className={`h-1.5 transition-colors duration-200 ${
+                  isExpanded ? "bg-[rgb(20,113,76)]" : "bg-gray-200 dark:bg-gray-700"
+                }`}
+              />
+            </div>
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+
+function ChevronDownIcon({ isExpanded }: { isExpanded: boolean }) {
+  return (
+    <svg
+      viewBox="0 0 24 24"
+      fill="none"
+      stroke="currentColor"
+      strokeWidth="2"
+      strokeLinecap="round"
+      strokeLinejoin="round"
+      className={`w-4 h-4 transition-transform duration-200 flex-shrink-0 ${
+        isExpanded ? "rotate-180 text-[rgb(20,113,76)]" : "text-gray-400"
+      }`}
+    >
+      <path d="m6 9 6 6 6-6" />
+    </svg>
+  );
+}
diff --git a/apps/edr-passenger-web/portal/src/components/StationDropdown.tsx b/apps/edr-passenger-web/portal/src/components/StationDropdown.tsx
new file mode 100644
index 000000000..8b0fb0073
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/components/StationDropdown.tsx
@@ -0,0 +1,215 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { Clock, MapPin, X } from "lucide-react";
+import { Station } from "@/types";
+
+// Shared by the search widget (home page) and the reschedule flow so both pick stations the
+// same way. Recents live under one localStorage key, so a station picked on the home page is
+// still offered as "Recent" when rescheduling.
+export const RECENT_STATIONS_KEY = "edr_recent_stations";
+export const MAX_RECENT_STATIONS = 5;
+
+export function readRecentStationIds(): string[] {
+  try {
+    const raw = JSON.parse(localStorage.getItem(RECENT_STATIONS_KEY) || "[]");
+    return Array.isArray(raw) ? raw : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Prepends `id`, de-duplicates, caps the list, persists it, and returns the new list. */
+export function pushRecentStation(id: string, prev: string[]): string[] {
+  const next = [id, ...prev.filter((x) => x !== id)].slice(0, MAX_RECENT_STATIONS);
+  try {
+    localStorage.setItem(RECENT_STATIONS_KEY, JSON.stringify(next));
+  } catch {
+    /* private mode / storage disabled — recents are a convenience, never a requirement */
+  }
+  return next;
+}
+
+// ─── Station Autocomplete ─────────────────────────────────────────────────────
+export default function StationDropdown({
+  stations,
+  value,
+  excludeId,
+  placeholder,
+  onSelect,
+  error,
+  recentIds,
+  onOpen,
+  disabled = false,
+}: {
+  stations: Station[];
+  value: string;
+  excludeId?: string;
+  placeholder: string;
+  onSelect: (s: Station) => void;
+  error?: string;
+  recentIds: string[];
+  onOpen?: () => void;
+  /**
+   * Read-only: shows the selection but refuses to open. Used where the route is fixed —
+   * a fare class whose policy sets `routeChangeAllowed: false` cannot change stations, and
+   * a dropdown that opens only to reject the pick is worse than one that plainly can't.
+   */
+  disabled?: boolean;
+}) {
+  const [query, setQuery] = useState("");
+  const [open, setOpen] = useState(false);
+  const ref = useRef<HTMLDivElement>(null);
+  const inputRef = useRef<HTMLInputElement>(null);
+  const selectedStation = stations.find((s) => s.id === value);
+
+  useEffect(() => {
+    if (selectedStation && !open) setQuery("");
+  }, [selectedStation, open]);
+
+  // Close if the control is disabled while open (e.g. switching to a route-locked leg).
+  useEffect(() => {
+    if (disabled) setOpen(false);
+  }, [disabled]);
+
+  useEffect(() => {
+    const handler = (e: MouseEvent) => {
+      if (ref.current && !ref.current.contains(e.target as Node))
+        setOpen(false);
+    };
+    document.addEventListener("mousedown", handler);
+    return () => document.removeEventListener("mousedown", handler);
+  }, []);
+
+  const filtered = query.trim()
+    ? stations.filter(
+        (s) =>
+          s.id !== excludeId &&
+          (s.name.toLowerCase().includes(query.toLowerCase()) ||
+            s.code?.toLowerCase().includes(query.toLowerCase())),
+      )
+    : stations.filter((s) => s.id !== excludeId).slice(0, 20);
+
+  const displayValue = open ? query : (selectedStation?.name ?? "");
+
+  return (
+    <div ref={ref} className="relative">
+      <div
+        className={`relative flex items-center border-2 rounded-xl transition-all duration-200 ${
+          disabled
+            ? "bg-gray-50 dark:bg-gray-900 border-gray-200 dark:border-gray-700"
+            : "bg-white dark:bg-gray-800"
+        } ${
+          error
+            ? "border-red-400"
+            : disabled
+              ? ""
+              : open
+                ? "border-primary ring-2 ring-primary/20"
+                : "border-gray-200 dark:border-gray-700 hover:border-gray-300 dark:hover:border-gray-600"
+        }`}
+      >
+        <MapPin
+          className={`absolute left-3.5 w-4 h-4 flex-shrink-0 ${disabled ? "text-gray-400" : "text-primary"}`}
+        />
+        <input
+          ref={inputRef}
+          value={displayValue}
+          readOnly={disabled}
+          disabled={disabled}
+          onChange={(e) => {
+            setQuery(e.target.value);
+            setOpen(true);
+          }}
+          onFocus={() => {
+            if (disabled) return;
+            setQuery("");
+            setOpen(true);
+            onOpen?.();
+          }}
+          placeholder={placeholder}
+          className={`w-full pl-10 pr-8 py-3.5 bg-transparent rounded-xl focus:outline-none text-sm placeholder-gray-400 ${
+            disabled
+              ? "text-gray-500 dark:text-gray-400 cursor-not-allowed"
+              : "text-gray-900 dark:text-white"
+          }`}
+        />
+        {value && !disabled && (
+          <button
+            type="button"
+            onClick={() => {
+              onSelect({ id: "", name: "", code: "", country: "" });
+              setQuery("");
+            }}
+            className="absolute right-3 p-0.5"
+          >
+            <X className="w-3.5 h-3.5 text-gray-400 hover:text-gray-600" />
+          </button>
+        )}
+      </div>
+
+      {open && !disabled && (
+        <div className="absolute top-full left-0 right-0 mt-2 bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-xl shadow-xl z-[200] max-h-96 overflow-y-auto overflow-x-hidden scrollbar-hide">
+          {!query && recentIds.length > 0 && (
+            <div className="px-3 pt-2 pb-1">
+              <p className="text-[10px] font-semibold text-gray-400 uppercase tracking-wide mb-1">
+                Recent
+              </p>
+              {recentIds
+                .map((id) => stations.find((s) => s.id === id))
+                .filter(Boolean)
+                .map((s) => (
+                  <button
+                    key={s!.id}
+                    type="button"
+                    onMouseDown={() => {
+                      onSelect(s!);
+                      setOpen(false);
+                      setQuery("");
+                    }}
+                    className="w-full flex items-center gap-2 px-2 py-2 rounded-lg hover:bg-gray-50 dark:hover:bg-gray-700 text-left"
+                  >
+                    <Clock className="w-3.5 h-3.5 text-primary flex-shrink-0" />
+                    <span className="text-sm text-gray-800 dark:text-gray-200">
+                      {s!.name}
+                    </span>
+                  </button>
+                ))}
+              <div className="border-t border-gray-100 dark:border-gray-700 mt-1 mb-1" />
+            </div>
+          )}
+          {filtered.length === 0 ? (
+            <p className="text-sm text-gray-400 text-center py-4">
+              No stations found
+            </p>
+          ) : (
+            filtered.map((s) => (
+              <button
+                key={s.id}
+                type="button"
+                onMouseDown={() => {
+                  onSelect(s);
+                  setOpen(false);
+                  setQuery("");
+                }}
+                className="w-full flex items-center gap-2 px-3 py-2.5 hover:bg-gray-50 dark:hover:bg-gray-700 text-left transition-colors"
+              >
+                <MapPin className="w-3.5 h-3.5 text-primary flex-shrink-0" />
+                <div>
+                  <span className="text-sm font-medium text-gray-900 dark:text-white">
+                    {s.name}
+                  </span>
+                  {s.code && (
+                    <span className="text-xs text-gray-400 ml-1.5">
+                      {s.code}
+                    </span>
+                  )}
+                </div>
+              </button>
+            ))
+          )}
+        </div>
+      )}
+    </div>
+  );
+}
diff --git a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
index de306da8f..c0e1eacbe 100644
--- a/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
+++ b/apps/edr-passenger-web/portal/src/lib/generate-voucher.ts
@@ -40,6 +40,8 @@ interface PassengerVoucherData {
   // payment.amountMinor straight from the API) and must NOT be divided by 100 — as
   // opposed to the normal case where fareMinor is genuine minor units (cents).
   fareIsMajorUnits?: boolean;
+  /** Itemises the total when a booking was paid more than once (e.g. after a reschedule). */
+  paymentLines?: Array<{ label: string; amountMinor: number; currency: string; status: string; settled: boolean }>;
 }
 
 // ─── palette ───────────────────────────────────────────────────────────────
@@ -365,6 +367,43 @@ function drawFareSummary(doc: jsPDF, fareMinor: number, currency: string, y: num
 
   return y + cardH + 6;
 }
+function drawPaymentBreakdown(
+  doc: jsPDF,
+  lines: Array<{ label: string; amountMinor: number; currency: string; status: string; settled: boolean }>,
+  y: number,
+  margin: number,
+  pageWidth: number,
+): number {
+  if (lines.length < 2) return y;
+
+  const rowH = 6;
+  const padX = 7;
+  const headerH = 7;
+  const cardH = headerH + lines.length * rowH + 3;
+
+  doc.setDrawColor(...HAIRLINE);
+  doc.setLineWidth(0.2);
+  doc.roundedRect(margin, y, pageWidth - margin * 2, cardH, 3, 3, 'S');
+
+  doc.setFontSize(7.5); doc.setFont('helvetica', 'bold'); doc.setTextColor(...MUTED);
+  doc.text('PAYMENT BREAKDOWN', margin + padX, y + 5, { charSpace: 0.2 });
+
+  lines.forEach((line, i) => {
+    const rowY = y + headerH + i * rowH;
+    doc.setFontSize(8.5); doc.setFont('helvetica', 'normal'); doc.setTextColor(...BODY);
+    // No status suffix: the caller passes settled lines only, so every row here is paid.
+    doc.text(line.label, margin + padX, rowY + 4);
+    doc.setFont('helvetica', 'bold'); doc.setTextColor(...INK);
+    doc.text(
+      `${line.currency} ${(line.amountMinor / 100).toFixed(2)}`,
+      pageWidth - margin - padX,
+      rowY + 4,
+      { align: 'right' },
+    );
+  });
+
+  return y + cardH + 6;
+}
 
 // ─── instructions ──────────────────────────────────────────────────────────
 
@@ -425,6 +464,7 @@ async function drawPassengerVoucherPage(doc: jsPDF, data: PassengerVoucherData):
 
   y = drawPassengerDetails(doc, data, y, margin, pageW);
   y = drawFareSummary(doc, data.fareMinor, data.currency, y, margin, pageW, data.fareIsMajorUnits);
+  y = drawPaymentBreakdown(doc, data.paymentLines ?? [], y, margin, pageW);
   y = drawInstructions(doc, y, margin, pageW);
   drawFooter(doc, data.createdAt, y);
 }
@@ -474,15 +514,32 @@ interface VoucherData {
   tickets?: Array<{ passengerName?: string; leg?: number; barcodePayload?: string }>;
   // The actual settled amount/currency for this booking's payment — preferred over the
   // ETB booking total once available, since it reflects what was really charged.
-  payment?: { amountMinor?: number; currency?: string };
+  payment?: {
+    amountMinor?: number;
+    currency?: string;
+    /** Every line collected for this booking — see the API's payment-breakdown.util.ts. */
+    breakdown?: {
+      lines: Array<{ label: string; amountMinor: number; currency: string; status: string; settled: boolean }>;
+      totalPaidMinor: number | null;
+      totalPaidCurrency: string | null;
+    };
+  };
 }
 
 export const generateVoucherPDF = async (booking: VoucherData): Promise<void> => {
   // Currency always comes straight from the booking/payment data, never hardcoded — the
   // settled payment currency when a payment has settled, otherwise the booking's own
   // display currency (falling back to the internal ETB currency field).
-  const settledAmountMinor = booking.payment?.amountMinor;
-  const settledCurrency = booking.payment?.currency;
+  // `payment.amountMinor` is the ORIGINAL intent only — it never moves when a booking is
+  // rescheduled, so a voucher built from it reports the pre-reschedule amount forever (a 51.85
+  // booking moved to a 1752.34 journey still printed 51.85). `payment.breakdown` counts every
+  // line collected, including the reschedule fee and fare difference. It arrives in true minor
+  // units, so it is divided down to the major-unit basis the rest of this function expects.
+  const breakdown = booking.payment?.breakdown;
+  const settledAmountMinor =
+    breakdown?.totalPaidMinor != null ? breakdown.totalPaidMinor / 100 : booking.payment?.amountMinor;
+  const settledCurrency =
+    (breakdown?.totalPaidMinor != null ? breakdown.totalPaidCurrency : booking.payment?.currency) ?? undefined;
   const useSettledAmount = settledAmountMinor != null && !!settledCurrency;
   // Prefer displayCurrency (passenger's home currency) over the internal ETB currency field.
   const voucherCurrency = useSettledAmount ? settledCurrency! : (booking.displayCurrency || booking.currency || 'ETB');
@@ -541,7 +598,10 @@ export const generateVoucherPDF = async (booking: VoucherData): Promise<void> =>
 
     // This passenger's own fare, scaled onto the same currency/amount basis as the rest of
     // the voucher — not the booking's overall total, and not an equal share of it.
-    const passengerFareMinor = Math.round(p.fareMinor * fareScaleFactor);
+    const scaledFare = p.fareMinor * fareScaleFactor;
+    const passengerFareMinor = useSettledAmount
+      ? Math.round(scaledFare * 100) / 100
+      : Math.round(scaledFare);
 
     await generatePassengerVoucherPDF({
       bookingRef:           booking.bookingRef,
@@ -560,6 +620,7 @@ export const generateVoucherPDF = async (booking: VoucherData): Promise<void> =>
       fareMinor:            passengerFareMinor,
       currency:             voucherCurrency,
       fareIsMajorUnits:     useSettledAmount,
+      paymentLines:         grouped.size === 1 ? breakdown?.lines.filter((l) => l.settled) : undefined,
       createdAt:            booking.createdAt,
     });
   }
diff --git a/apps/edr-passenger-web/portal/src/utils/phone.ts b/apps/edr-passenger-web/portal/src/utils/phone.ts
new file mode 100644
index 000000000..d30ff28ea
--- /dev/null
+++ b/apps/edr-passenger-web/portal/src/utils/phone.ts
@@ -0,0 +1,16 @@
+
+export function normalizePhone(phone?: string | null): string | null {
+  if (!phone) return null;
+  const digits = phone.replace(/\D/g, '');
+  if (!digits) return null;
+  if (digits.startsWith('251')) return `+${digits}`;
+  if (digits.startsWith('0')) return `+251${digits.slice(1)}`;
+  if (digits.length === 9) return `+251${digits}`;
+  return `+${digits}`;
+}
+
+export function samePhone(a?: string | null, b?: string | null): boolean {
+  const left = normalizePhone(a);
+  const right = normalizePhone(b);
+  return !!left && !!right && left === right;
+}