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/app.module.ts b/apps/edr-freight-api/src/app.module.ts
index 397845cb3..a310e496b 100644
--- a/apps/edr-freight-api/src/app.module.ts
+++ b/apps/edr-freight-api/src/app.module.ts
@@ -35,6 +35,7 @@ import { ConsignmentsModule } from "./modules/consignments/consignments.module";
 import { LocomotivesModule } from "./modules/locomotives/locomotives.module";
 import { TruckTypesModule } from "./modules/truck-types/truck-types.module";
 import { TransitAgentsModule } from "./modules/transit-agents/transit-agents.module";
+import { TransitAssignmentsModule } from "./modules/transit-assignments/transit-assignments.module";
 import { WagonTypesModule } from "./modules/wagon-types/wagon-types.module";
 import { TrainSetsModule } from "./modules/train-sets/train-sets.module";
 import { TrainSchedulesModule } from "./modules/train-schedules/train-schedules.module";
@@ -205,6 +206,7 @@ if (!process.env.APPLICATION_NAME) {
     LocomotivesModule,
     TruckTypesModule,
     TransitAgentsModule,
+    TransitAssignmentsModule,
     WagonTypesModule,
     TrainSetsModule,
     TrainSchedulesModule,
diff --git a/apps/edr-freight-api/src/common/validators/is-phone-number.validator.ts b/apps/edr-freight-api/src/common/validators/is-phone-number.validator.ts
index 4f060ca11..c4588af07 100644
--- a/apps/edr-freight-api/src/common/validators/is-phone-number.validator.ts
+++ b/apps/edr-freight-api/src/common/validators/is-phone-number.validator.ts
@@ -4,25 +4,29 @@ import {
   ValidationOptions,
   ValidatorConstraint,
   ValidatorConstraintInterface,
-} from 'class-validator';
-import { isValidPhoneNumber, parsePhoneNumberFromString } from 'libphonenumber-js';
+} from "class-validator";
+import {
+  isValidPhoneNumber,
+  parsePhoneNumberFromString,
+} from "libphonenumber-js";
 
 /**
  * Country-aware phone validation. The value is expected as a full international
- * number (E.164, e.g. "+251911223344"), so the country is derived from the
- * value itself — no separate country field needed.
+ * number (E.164, e.g. "+25377834567" for Djibouti or "+251911223344" for
+ * Ethiopia), so the country is derived from the value itself — no separate
+ * country field needed.
  */
-@ValidatorConstraint({ name: 'IsValidPhone', async: false })
+@ValidatorConstraint({ name: "IsValidPhone", async: false })
 export class IsValidPhoneConstraint implements ValidatorConstraintInterface {
   validate(value: unknown): boolean {
     // Empty is allowed here; pair with @IsOptional / @IsNotEmpty as needed.
-    if (value === undefined || value === null || value === '') return true;
-    if (typeof value !== 'string') return false;
+    if (value === undefined || value === null || value === "") return true;
+    if (typeof value !== "string") return false;
     return isValidPhoneNumber(value);
   }
 
   defaultMessage(args: ValidationArguments): string {
-    return `${args.property} must be a valid international phone number (E.164, e.g. +251911223344)`;
+    return `${args.property} must be a complete international phone number (E.164, e.g. +25377834567 or +251911223344)`;
   }
 }
 
@@ -53,7 +57,7 @@ export function IsValidPhone(validationOptions?: ValidationOptions) {
 export function normalizeE164(
   value: string | null | undefined,
 ): string | null | undefined {
-  if (value === undefined || value === null || value === '') return value;
-  const parsed = parsePhoneNumberFromString(value, 'ET');
+  if (value === undefined || value === null || value === "") return value;
+  const parsed = parsePhoneNumberFromString(value, "ET");
   return parsed?.isValid() ? parsed.number : value.trim();
 }
diff --git a/apps/edr-freight-api/src/migrations/3790000000000-TransitAgentAccount.ts b/apps/edr-freight-api/src/migrations/3790000000000-TransitAgentAccount.ts
new file mode 100644
index 000000000..eedf8b149
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3790000000000-TransitAgentAccount.ts
@@ -0,0 +1,55 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Give a transit agent a portal login.
+ *
+ * Every column is NULLABLE and nothing is backfilled: production already holds
+ * transit agents that exist only as a GL-assignable roster entry, and they must
+ * keep working untouched. An agent gains an account when staff invite it — at
+ * which point `user_id` is filled in — so "has a login" is exactly
+ * `user_id IS NOT NULL`, and the assignment flow never has to care.
+ *
+ * The unique indexes are partial (`WHERE ... IS NOT NULL`) because Postgres
+ * treats NULLs as distinct in a plain unique index only per-row; being explicit
+ * documents that many account-less agents are expected to coexist.
+ */
+export class TransitAgentAccount3790000000000 implements MigrationInterface {
+  name = "TransitAgentAccount3790000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE freight.transit_agents
+         ADD COLUMN IF NOT EXISTS user_id uuid,
+         ADD COLUMN IF NOT EXISTS email varchar(150),
+         ADD COLUMN IF NOT EXISTS phone_number varchar(30)`,
+    );
+    // One IAM account can back at most one transit agent — otherwise a single
+    // login would resolve to two agents in `findByUserId`.
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX IF NOT EXISTS ux_transit_agents_user_id
+         ON freight.transit_agents (user_id)
+       WHERE user_id IS NOT NULL AND deleted_at IS NULL`,
+    );
+    // Case-insensitive, matching how the repository checks for duplicates.
+    await queryRunner.query(
+      `CREATE UNIQUE INDEX IF NOT EXISTS ux_transit_agents_email
+         ON freight.transit_agents (lower(email))
+       WHERE email IS NOT NULL AND deleted_at IS NULL`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS freight.ux_transit_agents_email`,
+    );
+    await queryRunner.query(
+      `DROP INDEX IF EXISTS freight.ux_transit_agents_user_id`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE freight.transit_agents
+         DROP COLUMN IF EXISTS phone_number,
+         DROP COLUMN IF EXISTS email,
+         DROP COLUMN IF EXISTS user_id`,
+    );
+  }
+}
diff --git a/apps/edr-freight-api/src/migrations/3800000000000-BookingCancellationWagons.ts b/apps/edr-freight-api/src/migrations/3800000000000-BookingCancellationWagons.ts
new file mode 100644
index 000000000..df994d832
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3800000000000-BookingCancellationWagons.ts
@@ -0,0 +1,35 @@
+import { MigrationInterface, QueryRunner } from 'typeorm';
+
+/**
+ * Wagon footprint pinned for cancellation pricing. `wagons_required` is a LIVE
+ * scheduling field — unassign clears it to NULL — so a paid booking pulled off
+ * a train had nothing left to price a cancellation fee or credit against
+ * ("This booking has no wagon requirement to cancel from."). This column is
+ * stamped once, at first allocation, and never cleared: cancellation reads it
+ * (falling back to a computed count for bookings never allocated).
+ */
+export class BookingCancellationWagons3800000000000 implements MigrationInterface {
+  name = 'BookingCancellationWagons3800000000000';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        ADD COLUMN IF NOT EXISTS cancellation_wagons numeric(6,2)
+    `);
+    // Backfill the bookings that still carry a live stamp.
+    await queryRunner.query(`
+      UPDATE freight.bookings
+         SET cancellation_wagons = wagons_required
+       WHERE cancellation_wagons IS NULL
+         AND wagons_required IS NOT NULL
+         AND wagons_required > 0
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      ALTER TABLE freight.bookings
+        DROP COLUMN IF EXISTS cancellation_wagons
+    `);
+  }
+}
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-TransitAssignments.ts b/apps/edr-freight-api/src/migrations/3810000000000-TransitAssignments.ts
new file mode 100644
index 000000000..9d0116681
--- /dev/null
+++ b/apps/edr-freight-api/src/migrations/3810000000000-TransitAssignments.ts
@@ -0,0 +1,72 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/**
+ * Transit assignments — one row per (booking × transit agent), so an agent
+ * handles many bookings.
+ *
+ * Deliberately NOT the existing transit-assignee handshake on bookings
+ * (`/bookings/:id/clearance/transit-assignee/...`, which stores its answer on
+ * the booking itself): that is a pre-declaration agreement between GL Ethiopia
+ * and GL Djibouti about WHO will handle customs. This is the work record —
+ * status, timings and documents — and nothing here reads or writes that flow.
+ *
+ * There is no duration column on purpose. The time taken after the train
+ * arrives is `finished_at − bookings.arrived_at`, and both halves already
+ * exist; storing the difference would be a third source of truth that goes
+ * stale the moment either timestamp is corrected. It is computed on read.
+ *
+ * Documents hang off `freight.files` with `resource = 'transit_assignments'`
+ * and `resource_id = transit_assignments.id`. That table already carries the
+ * MinIO object, the upload time (`created_at`), the uploader, the edit time
+ * (`updated_at`) and the supersede history, so no file table is added here.
+ */
+export class TransitAssignments3810000000000 implements MigrationInterface {
+  name = "TransitAssignments3810000000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`
+      CREATE TABLE IF NOT EXISTS freight.transit_assignments (
+        id uuid NOT NULL DEFAULT gen_random_uuid(),
+        booking_id uuid NOT NULL,
+        transit_agent_id uuid NOT NULL,
+        status varchar(32) NOT NULL DEFAULT 'NOT_STARTED',
+        started_at timestamptz,
+        finished_at timestamptz,
+        assigned_by_user_id uuid,
+        assigned_at timestamptz NOT NULL DEFAULT now(),
+        note text,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        deleted_at timestamptz,
+        CONSTRAINT pk_transit_assignments PRIMARY KEY (id),
+        CONSTRAINT fk_transit_assignments_booking
+          FOREIGN KEY (booking_id) REFERENCES freight.bookings (id),
+        CONSTRAINT fk_transit_assignments_agent
+          FOREIGN KEY (transit_agent_id) REFERENCES freight.transit_agents (id)
+      )
+    `);
+
+    // One live assignment per (booking, agent). Partial so a soft-deleted row
+    // never blocks re-assigning the same agent to the same booking later.
+    await queryRunner.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS ux_transit_assignments_booking_agent
+        ON freight.transit_assignments (booking_id, transit_agent_id)
+        WHERE deleted_at IS NULL
+    `);
+
+    // The two list directions: a booking's assignments, and an agent's workload.
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS ix_transit_assignments_booking
+        ON freight.transit_assignments (booking_id) WHERE deleted_at IS NULL
+    `);
+    await queryRunner.query(`
+      CREATE INDEX IF NOT EXISTS ix_transit_assignments_agent_status
+        ON freight.transit_assignments (transit_agent_id, status)
+        WHERE deleted_at IS NULL
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`DROP TABLE IF EXISTS freight.transit_assignments`);
+  }
+}
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/bookings/booking-wagon-cancellation.service.spec.ts b/apps/edr-freight-api/src/modules/bookings/booking-wagon-cancellation.service.spec.ts
index 66ee2cbbb..314d31a7f 100644
--- a/apps/edr-freight-api/src/modules/bookings/booking-wagon-cancellation.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/bookings/booking-wagon-cancellation.service.spec.ts
@@ -17,6 +17,7 @@ describe('BookingWagonCancellationService.resolveRequestedCut (bulk)', () => {
       wagons: number;
       weightTons: number;
       quantities: { bulkTons?: number };
+      totalWagons: number;
     }>;
   };
   const booking = {
@@ -29,7 +30,39 @@ describe('BookingWagonCancellationService.resolveRequestedCut (bulk)', () => {
 
   it('cancels every wagon with the exact total tonnage', async () => {
     const cut = await svc.resolveRequestedCut(booking, { wagons: 4 });
-    expect(cut).toEqual({ wagons: 4, weightTons: 250.5, quantities: { bulkTons: 250.5 } });
+    expect(cut).toEqual({
+      wagons: 4,
+      weightTons: 250.5,
+      quantities: { bulkTons: 250.5 },
+      totalWagons: 4,
+    });
+  });
+
+  /**
+   * Unassigning a paid booking from a train clears `wagonsRequired` to NULL, so
+   * cancellation used to reject it outright ("no wagon requirement to cancel
+   * from"). The pinned `cancellationWagons`, stamped at first allocation, keeps
+   * the footprint through the unassign.
+   */
+  it('falls back to the pinned cancellation footprint when wagonsRequired is cleared', async () => {
+    const unassigned = { ...booking, wagonsRequired: null, cancellationWagons: 4 };
+    const cut = await svc.resolveRequestedCut(unassigned, { wagons: 4 });
+    expect(cut.wagons).toBe(4);
+    expect(cut.totalWagons).toBe(4);
+    expect(cut.weightTons).toBe(250.5);
+  });
+
+  /** NUMBER_OF_WAGONS bulk never allocated: the customer's pinned count sizes it. */
+  it('sizes a never-allocated NUMBER_OF_WAGONS booking from bulkRequestedWagons', async () => {
+    const fresh = {
+      ...booking,
+      wagonsRequired: null,
+      cancellationWagons: null,
+      bulkRequestedWagons: 3,
+    };
+    const cut = await svc.resolveRequestedCut(fresh, { wagons: 3 });
+    expect(cut.totalWagons).toBe(3);
+    expect(cut.weightTons).toBe(250.5);
   });
 
   it('rejects more wagons than the booking has', async () => {
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 64ccb1929..a84f0907f 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
@@ -23,6 +23,8 @@ import { wagonsPerUnitForSize } from '../rule-engine/container-type.util';
 import { ContainerType } from '../rule-engine/entities/container-type.entity';
 import { Rate } from '../rule-engine/entities/rate.entity';
 import { BookingBatchService } from '../train-scheduling/booking-batch.service';
+import { requestedBulkWagons } from '../train-scheduling/train-capacity.util';
+import { wagonsRequiredForBooking } from '../train-scheduling/utils/fleet-plan.util';
 import { TrainSchedulingService } from '../train-scheduling/services/train-scheduling.service';
 import { TrainScheduleBooking } from '../train-schedules/entities/train-schedule-booking.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
@@ -74,6 +76,8 @@ interface RequestedCut {
   wagons: number;
   weightTons: number;
   quantities: CancelledQuantities;
+  /** The booking's whole wagon footprint the cut came out of — credit divides by it. */
+  totalWagons: number;
 }
 
 /** The priced fee for a cut: total, currency and the rate(s) it came from. */
@@ -165,7 +169,7 @@ export class BookingWagonCancellationService {
           feePerWagon: fee.perWagon,
           feeAmount: fee.amount,
           feeCurrency: fee.currency,
-          creditAmount: this.creditFor(booking, Number(booking.wagonsRequired ?? 0)),
+          creditAmount: round2(Number(booking.totalAmount ?? 0)),
         };
       }
       this.assertCutSparesSharedWagon(cut);
@@ -177,7 +181,7 @@ export class BookingWagonCancellationService {
       feePerWagon: fee.perWagon,
       feeAmount: fee.amount,
       feeCurrency: fee.currency,
-      creditAmount: this.creditFor(booking, cut.wagons),
+      creditAmount: this.creditFor(booking, cut.wagons, cut.totalWagons),
     };
   }
 
@@ -218,7 +222,7 @@ export class BookingWagonCancellationService {
       : await this.resolveRequestedCut(booking, dto);
     const fee = await this.priceFee(booking, cut);
     const feeAmount = fee.amount;
-    const creditAmount = this.creditFor(booking, cut.wagons);
+    const creditAmount = this.creditFor(booking, cut.wagons, cut.totalWagons);
 
     const row = await this.repo.create({
       bookingId,
@@ -318,7 +322,7 @@ export class BookingWagonCancellationService {
         const rows = await this.dataSource.getRepository(WagonBookingAllocation).count({
           where: { bookingId: row.bookingId },
         });
-        if (rows < Math.round(Number(booking.wagonsRequired ?? 0))) {
+        if (rows < Math.round(await this.wagonFootprint(booking))) {
           throw new ConflictException(
             'The train has no free wagon space left to restore the cancelled wagons — the request cannot be withdrawn. Pay the cancellation fee and rebook the credit on another day instead.',
           );
@@ -363,7 +367,7 @@ export class BookingWagonCancellationService {
     const row = await this.openConsolidationBreak(
       booking,
       'ceil',
-      this.creditFor(booking, Number(booking.wagonsRequired ?? 0)),
+      round2(Number(booking.totalAmount ?? 0)),
       reason ?? 'Consolidated pair cancelled',
       userId,
     );
@@ -371,7 +375,7 @@ export class BookingWagonCancellationService {
       await this.openConsolidationBreak(
         partner,
         'floor',
-        this.creditFor(partner, Number(partner.wagonsRequired ?? 0)),
+        round2(Number(partner.totalAmount ?? 0)),
         `Cancelled with its consolidation partner ${booking.reference}`,
         userId,
       );
@@ -540,7 +544,8 @@ export class BookingWagonCancellationService {
       } as RequestWagonCancellationDto);
     }
     return this.resolveRequestedCut(booking, {
-      wagons: Number(booking.wagonsRequired ?? 0),
+      // Footprint, not the live wagonsRequired: unassign clears that to NULL.
+      wagons: await this.wagonFootprint(booking),
     } as RequestWagonCancellationDto);
   }
 
@@ -568,7 +573,7 @@ export class BookingWagonCancellationService {
       const row = await this.openConsolidationBreak(
         booking,
         'ceil',
-        this.creditFor(booking, Number(booking.wagonsRequired ?? 0)),
+        round2(Number(booking.totalAmount ?? 0)),
         'Consolidation partner lapsed unpaid — paired booking cancelled, cancellation fee applies',
       );
       await this.dataSource.getRepository(Booking).update(booking.id, {
@@ -729,9 +734,10 @@ export class BookingWagonCancellationService {
       // Whole-booking cut: nothing is left to ship, so the booking ends
       // CANCELLED (frees the contract slot/cap for the rebook) and drops off its
       // train. The credit row still points at it for T3.
-      const wagonsLeft = round2(
-        Number(booking.wagonsRequired ?? 0) - Number(row.wagonsCancelled),
-      );
+      // Off the pinned footprint, not the live wagonsRequired — unassign
+      // clears that to NULL, which read as a full cut on any partial cancel.
+      const footprint = await this.wagonFootprint(booking);
+      const wagonsLeft = round2(footprint - Number(row.wagonsCancelled));
       const isFull = wagonsLeft <= 0;
       // NUMBER_OF_WAGONS bookings pin their count in bulkRequestedWagons, which
       // bulkTonWagonsRequired honours verbatim. Left stale it re-inflates the
@@ -745,6 +751,9 @@ export class BookingWagonCancellationService {
         : null;
       await manager.getRepository(Booking).update(booking.id, {
         wagonsRequired: Math.max(0, wagonsLeft),
+        // Keep the cancellation footprint in step, so a second partial cancel
+        // prices against what is actually left, not the original booking.
+        cancellationWagons: Math.max(0, wagonsLeft),
         ...(requestedWagonsLeft !== null
           ? { bulkRequestedWagons: requestedWagonsLeft }
           : {}),
@@ -853,14 +862,37 @@ export class BookingWagonCancellationService {
       );
     }
 
+    // Staff may cut a SUBSET of the never-loaded wagons (picked in the loading
+    // modal) instead of the whole remainder. Anything already LOADED is
+    // rejected rather than silently dropped: the operator believes they are
+    // cancelling that wagon, and it is on the train.
+    let target = remaining;
+    if (dto.wagonAllocationIds?.length) {
+      const wanted = new Set(dto.wagonAllocationIds);
+      const known = new Set(allocations.map((a) => a.id));
+      const unknown = dto.wagonAllocationIds.filter((id) => !known.has(id));
+      if (unknown.length) {
+        throw new BadRequestException(
+          'Some selected wagons are not allocated to this booking on this schedule.',
+        );
+      }
+      const loaded = allocations.filter((a) => wanted.has(a.id) && !remaining.includes(a));
+      if (loaded.length) {
+        throw new BadRequestException(
+          `${loaded.length} selected wagon(s) are already loaded and cannot be cancelled.`,
+        );
+      }
+      target = remaining.filter((a) => wanted.has(a.id));
+    }
+
     const cut = await this.resolveRequestedCut(booking, {
-      wagonAllocationIds: remaining.map((r) => r.id),
+      wagonAllocationIds: target.map((r) => r.id),
     } as RequestWagonCancellationDto);
     if (booking.consolidationPartnerId) this.assertCutSparesSharedWagon(cut);
 
     const edrFault = !!dto.edrFault;
     const fee = edrFault ? null : await this.priceFee(booking, cut);
-    const creditAmount = this.creditFor(booking, cut.wagons);
+    const creditAmount = this.creditFor(booking, cut.wagons, cut.totalWagons);
 
     const row = await this.repo.create({
       bookingId,
@@ -1253,7 +1285,7 @@ export class BookingWagonCancellationService {
     booking: Booking,
     dto: RequestWagonCancellationDto,
   ): Promise<RequestedCut> {
-    const totalWagons = Number(booking.wagonsRequired ?? 0);
+    const totalWagons = await this.wagonFootprint(booking);
     if (totalWagons <= 0) {
       throw new BadRequestException('This booking has no wagon requirement to cancel from.');
     }
@@ -1335,6 +1367,7 @@ export class BookingWagonCancellationService {
         weightTons: weightShare,
         // Bookings without unit records fall back to the T2 LIFO trim.
         quantities: { bySize, ...(units.length === requested ? { units } : {}) },
+        totalWagons,
       };
     }
 
@@ -1360,7 +1393,7 @@ export class BookingWagonCancellationService {
     if (tons <= 0) {
       throw new BadRequestException('The requested cut is too small to release cargo.');
     }
-    return { wagons, weightTons: tons, quantities: { bulkTons: tons } };
+    return { wagons, weightTons: tons, quantities: { bulkTons: tons }, totalWagons };
   }
 
   /**
@@ -1416,6 +1449,7 @@ export class BookingWagonCancellationService {
         wagons,
         weightTons: tons,
         quantities: { bulkTons: tons, allocationIds },
+        totalWagons,
       };
     }
 
@@ -1460,12 +1494,54 @@ export class BookingWagonCancellationService {
       wagons,
       weightTons: round3(units.reduce((s, u) => s + Number(u.vgmTons || 0), 0)),
       quantities: { bySize, units, allocationIds },
+      totalWagons,
     };
   }
 
+  /**
+   * The booking's wagon footprint for cancellation pricing.
+   *
+   * `wagonsRequired` is a LIVE scheduling field: unassign clears it to NULL, so
+   * a paid booking pulled off a train read 0 wagons and could not be cancelled
+   * at all. `cancellationWagons` is stamped once at first allocation and never
+   * cleared — read it first. A booking never allocated has neither, so size it
+   * from the cargo the same way the scheduler would: TEU geometry for
+   * containers, the customer's pinned count for NUMBER_OF_WAGONS bulk, tonnage
+   * ÷ wagon capacity for PER_TON bulk.
+   */
+  private async wagonFootprint(booking: Booking): Promise<number> {
+    const pinned = Number(booking.cancellationWagons ?? 0);
+    if (pinned > 0) return round2(pinned);
+    const stored = Number(booking.wagonsRequired ?? 0);
+    if (stored > 0) return round2(stored);
+
+    const requested = requestedBulkWagons(booking);
+    if (requested > 0) return requested;
+
+    // Cargo relations drive the sizing — reload when the caller passed a bare
+    // booking (findById does not always hydrate them).
+    const full =
+      booking.bookingContainers || booking.cargoType
+        ? booking
+        : ((await this.dataSource.getRepository(Booking).findOne({
+            where: { id: booking.id },
+            relations: {
+              bookingContainers: { containerType: true },
+              cargoType: { wagonTypes: true },
+            },
+          })) ?? booking);
+    const capacities = (full.cargoType?.wagonTypes ?? [])
+      .map((wt) => Number(wt.capacityTons))
+      .filter((c) => c > 0);
+    const bulkCapacity =
+      full.freightType === 'BULK' && capacities.length
+        ? Math.max(...capacities)
+        : undefined;
+    return round2(wagonsRequiredForBooking(full, bulkCapacity));
+  }
+
   /** Credit = the cancelled share of the ORIGINAL price (old-price rebooking). */
-  private creditFor(booking: Booking, wagons: number): number {
-    const totalWagons = Number(booking.wagonsRequired ?? 0);
+  private creditFor(booking: Booking, wagons: number, totalWagons: number): number {
     if (totalWagons <= 0) return 0;
     return round2(Number(booking.totalAmount) * (wagons / totalWagons));
   }
@@ -1875,9 +1951,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 5e0e3c994..863b61fee 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.repository.ts
@@ -1786,6 +1786,7 @@ export class BookingsRepository extends BaseRepository<Booking> {
         Booking,
         | 'schedulingStatus'
         | 'wagonsRequired'
+        | 'cancellationWagons'
         | 'scheduledAt'
         | 'holdStartedAt'
         | 'holdExpiresAt'
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 71107650f..5cdb0d6a4 100644
--- a/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
+++ b/apps/edr-freight-api/src/modules/bookings/bookings.service.ts
@@ -114,6 +114,8 @@ interface CarriageAcceptanceWagonRow {
   arrivalAt: string | null;
   containerNumbers: string | null;
   sealNumbers: string | null;
+  /** Allocation status — LOADED/DEPARTED means EDR has the cargo. */
+  status: string | null;
 }
 
 /** A received-but-not-yet-marshalled export line, standing in for a wagon row. */
@@ -263,9 +265,13 @@ export class BookingsService {
 
   /**
    * Carriage acceptance sheet — one per booking, listing every wagon the booking
-   * occupies. Handed to the customer when EDR accepts the cargo (export) and when
-   * the wagons are allocated before marshalling (import), so it is only available
-   * once the booking has wagon allocations.
+   * occupies. A booking is routinely loaded in parts (some containers go, the
+   * rest wait for the next train), so each row carries a Status of Loaded or
+   * Not loaded and the totals count only the loaded ones: the customer sees the
+   * whole plan on one page without the sheet overstating what EDR has taken.
+   *
+   * Handed to the customer when EDR accepts the cargo (export) and when the
+   * wagons are allocated before marshalling (import).
    */
   async carriageAcceptanceSheet(bookingId: string): Promise<{ filename: string; buffer: Buffer }> {
     const booking = await this.findById(bookingId);
@@ -285,6 +291,7 @@ export class BookingsService {
               s.scheduled_departure_date       AS "departureAt",
               so.label                         AS "marshalledAt",
               sd.label                         AS "arrivalAt",
+              a.status                         AS "status",
               string_agg(DISTINCT ci.container_number, ', ') AS "containerNumbers",
               string_agg(DISTINCT ci.seal_number, ', ')      AS "sealNumbers"
          FROM freight.wagon_booking_allocations a
@@ -299,7 +306,7 @@ export class BookingsService {
          LEFT JOIN freight.wagon_allocation_container_items ci
            ON ci.wagon_booking_allocation_id = a.id AND ci.deleted_at IS NULL
         WHERE a.booking_id = $1 AND a.deleted_at IS NULL
-        GROUP BY tsw.id, a.id, wt.code, wt.name, w.wagon_number, wt.tare_weight_tons,
+        GROUP BY tsw.id, a.id, a.status, wt.code, wt.name, w.wagon_number, wt.tare_weight_tons,
                  s.train_number, s.scheduled_departure_date, so.label, sd.label
         ORDER BY tsw.sequence_no`,
       [bookingId],
@@ -383,6 +390,8 @@ export class BookingsService {
         arrivalAt: null,
         containerNumbers: row.containerNumbers,
         sealNumbers: row.sealNumbers ?? null,
+        // A received line has no allocation; it is cargo EDR already holds.
+        status: null,
       }));
     }
 
@@ -497,7 +506,17 @@ export class BookingsService {
     const header = wagons[0];
     const sheetDate = header.departureAt ? new Date(header.departureAt) : new Date();
 
-    const totals = wagons.reduce(
+    // Loaded = EDR has the cargo. A booking is routinely loaded in parts, so the
+    // totals count only those: the sheet shows the whole plan, but must never
+    // total up cargo still sitting in the yard. A received-line sheet
+    // (pendingWagons) has no allocation status, and every line on it is cargo
+    // already accepted, so it counts in full.
+    const isLoaded = (w: CarriageAcceptanceWagonRow) =>
+      pendingWagons || w.status === 'LOADED' || w.status === 'DEPARTED';
+    const loadedWagons = wagons.filter(isLoaded);
+    const notLoadedCount = wagons.length - loadedWagons.length;
+
+    const totals = loadedWagons.reduce(
       (acc, w) => ({
         tare: acc.tare + (Number(w.tareWeightTons) || 0),
         capacity: acc.capacity + (Number(w.loadCapacityTons) || 0),
@@ -507,7 +526,7 @@ export class BookingsService {
       { tare: 0, capacity: 0, load: 0, length: 0 },
     );
     // A wagon carrying no weight and no container is running empty under this booking.
-    const fullWagons = wagons.filter(
+    const fullWagons = loadedWagons.filter(
       (w) => (Number(w.allocatedWeightTons) || 0) > 0 || Boolean(w.containerNumbers),
     ).length;
 
@@ -525,6 +544,9 @@ export class BookingsService {
           <td>${esc(departureStation)}</td>
           <td>${esc(w.containerNumbers)}</td>
           <td>${esc(w.sealNumbers)}</td>
+          <td class="${isLoaded(w) ? 'loaded' : 'pending'}">${
+            pendingWagons ? 'Accepted' : isLoaded(w) ? 'Loaded' : 'Not loaded'
+          }</td>
           <td class="num">${money(prices[i])}</td>
         </tr>`,
       )
@@ -535,11 +557,11 @@ export class BookingsService {
     // figure from the printed sheet.
     const totalsRow = `<tr class="totals">
         <td>TOT</td>
-        <td>${wagons.length} ${pendingWagons ? 'received lines' : 'wagons'}</td>
+        <td>${loadedWagons.length} ${pendingWagons ? 'received lines' : 'wagons loaded'}</td>
         <td>${
           pendingWagons
             ? 'pending marshalling'
-            : `full ${fullWagons} / empty ${wagons.length - fullWagons}`
+            : `full ${fullWagons} / empty ${loadedWagons.length - fullWagons}`
         }</td>
         <td class="num">${num(totals.tare, 2)}</td>
         <td class="num">${num(totals.length)}</td>
@@ -549,6 +571,7 @@ export class BookingsService {
         <td></td>
         <td></td>
         <td></td>
+        <td>${notLoadedCount > 0 ? `loaded only (${notLoadedCount} not loaded)` : ''}</td>
         <td class="num">${money(totalAmount)}</td>
       </tr>`;
 
@@ -575,6 +598,8 @@ export class BookingsService {
     th { background: #f8fafc; color: #475569; text-align: left; }
     th, td { border: 1px solid #cbd5e1; padding: 5px 6px; font-size: 9.5px; vertical-align: top; }
     .num { text-align: right; }
+    .loaded { color: #0f766e; font-weight: 700; }
+    .pending { color: #b45309; font-weight: 700; }
     tr.totals td { background: #f8fafc; font-weight: 700; }
     .notice { margin-top: 10px; border-left: 4px solid #0f766e; background: #f0fdfa; padding: 8px 10px; font-size: 10px; color: #134e4a; }
     .signatures { display: grid; grid-template-columns: repeat(3, 1fr); gap: 18px; margin-top: 34px; }
@@ -618,6 +643,7 @@ export class BookingsService {
         <th>Departure Station</th>
         <th>Container No.</th>
         <th>Seal No.</th>
+        <th>Status</th>
         <th class="num">Price (${esc(currency)})</th>
       </tr>
     </thead>
diff --git a/apps/edr-freight-api/src/modules/bookings/dto/wagon-cancellation.dto.ts b/apps/edr-freight-api/src/modules/bookings/dto/wagon-cancellation.dto.ts
index f86c3e4bf..7b4d3ca19 100644
--- a/apps/edr-freight-api/src/modules/bookings/dto/wagon-cancellation.dto.ts
+++ b/apps/edr-freight-api/src/modules/bookings/dto/wagon-cancellation.dto.ts
@@ -183,6 +183,19 @@ export class CancelRemainingWagonsDto {
   @IsUUID('4')
   scheduleId!: string;
 
+  @ApiPropertyOptional({
+    description:
+      'Cancel only THESE never-loaded wagons (wagon_booking_allocation ids from ' +
+      'GET /bookings/:id/wagons). Omit to cancel the whole unloaded remainder. ' +
+      'Already-loaded wagons are rejected — they are riding.',
+    type: [String],
+  })
+  @IsOptional()
+  @IsArray()
+  @ArrayNotEmpty()
+  @IsUUID('4', { each: true })
+  wagonAllocationIds?: string[];
+
   @ApiProperty({ description: 'Why the remaining wagons are not riding' })
   @IsString()
   @IsNotEmpty()
diff --git a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
index b86e1c3f3..9cf728a0d 100644
--- a/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
+++ b/apps/edr-freight-api/src/modules/bookings/entities/booking.entity.ts
@@ -543,6 +543,13 @@ export class Booking extends BaseEntity {
   @Column({ name: 'wagons_required', type: 'numeric', precision: 6, scale: 2, nullable: true })
   wagonsRequired?: number | null;
 
+  // Wagon footprint pinned for cancellation pricing. `wagonsRequired` above is
+  // a LIVE scheduling field that unassign clears; this one is stamped once at
+  // first allocation and never cleared, so a paid booking pulled off a train
+  // can still price its cancellation fee and credit.
+  @Column({ name: 'cancellation_wagons', type: 'numeric', precision: 6, scale: 2, nullable: true })
+  cancellationWagons?: number | null;
+
   @Column({ name: 'scheduling_status', type: 'varchar', length: 30, default: 'NOT_SCHEDULED' })
   schedulingStatus!: string;
 
diff --git a/apps/edr-freight-api/src/modules/companies/companies.controller.ts b/apps/edr-freight-api/src/modules/companies/companies.controller.ts
index 000b0733f..733b6e441 100644
--- a/apps/edr-freight-api/src/modules/companies/companies.controller.ts
+++ b/apps/edr-freight-api/src/modules/companies/companies.controller.ts
@@ -57,8 +57,10 @@ import { CompanyInfoResponseDto } from "./dto/company-info-response.dto";
 import {
   AccountInfoResponse,
   ShippingLineInfoResponseDto,
+  TransitAgentInfoResponseDto,
 } from "./dto/account-info-response.dto";
 import { ShippingLineCompaniesService } from "../shipping-lines/shipping-line-companies.service";
+import { TransitAgentsService } from "../transit-agents/transit-agents.service";
 import { UpdateProfileDto } from "./dto/update-profile.dto";
 import { ProfileResponseDto } from "./dto/profile-response.dto";
 import { DashboardSummaryResponseDto } from "./dto/dashboard-summary-response.dto";
@@ -104,6 +106,7 @@ export class CompaniesController {
     private readonly companiesService: CompaniesService,
     private readonly filesService: FilesService,
     private readonly shippingLineCompaniesService: ShippingLineCompaniesService,
+    private readonly transitAgentsService: TransitAgentsService,
   ) { }
 
   /**
@@ -133,10 +136,10 @@ export class CompaniesController {
   async getInfo(
     @CurrentUser() user: CurrentIamUser,
   ): Promise<AccountInfoResponse> {
-    // A shipping line has no company and no external profile, so the customer
-    // lookup below would 404. Checked first, and reported with an explicit
-    // `accountKind` so the portal can skip onboarding for shipping lines
-    // without inferring it from a missing company.
+    // Neither a shipping line nor a transit agent has a company or an external
+    // profile, so the customer lookup below would 404 for both. Checked first,
+    // and reported with an explicit `accountKind` so the portal can skip
+    // onboarding for them without inferring it from a missing company.
     const shippingLine = await this.shippingLineCompaniesService.findByUserId(
       user.id,
     );
@@ -144,6 +147,11 @@ export class CompaniesController {
       return new ShippingLineInfoResponseDto(shippingLine);
     }
 
+    const transitAgent = await this.transitAgentsService.findByUserId(user.id);
+    if (transitAgent) {
+      return new TransitAgentInfoResponseDto(transitAgent);
+    }
+
     const { profile, company } =
       await this.companiesService.getCompanyInfoByUserId(user.id);
     const review = await this.companiesService.getOpenChangeRequestForCompany(
diff --git a/apps/edr-freight-api/src/modules/companies/companies.module.ts b/apps/edr-freight-api/src/modules/companies/companies.module.ts
index 666634cb8..3a3d6c1c4 100644
--- a/apps/edr-freight-api/src/modules/companies/companies.module.ts
+++ b/apps/edr-freight-api/src/modules/companies/companies.module.ts
@@ -18,6 +18,7 @@ import { CompanyChangeRequest } from "./entities/company-change-request.entity";
 import { CompanyRevision } from "./entities/company-revision.entity";
 import { Booking } from "../bookings/entities/booking.entity";
 import { ShippingLineCompaniesModule } from "../shipping-lines/shipping-line-companies.module";
+import { TransitAgentsModule } from "../transit-agents/transit-agents.module";
 import { CompanyProfileRepository } from "./company-profile.repository";
 import { CompanyChangeRequestRepository } from "./company-change-request.repository";
 import { CompanyRevisionRepository } from "./company-revision.repository";
@@ -49,6 +50,10 @@ import { VerifaydaModule } from "../verifayda/verifayda.module";
     // shipping-line session, which has no company row to look up. forwardRef
     // because that module imports BillingModule, which imports this one.
     forwardRef(() => ShippingLineCompaniesModule),
+    // `GET /companies/getInfo` resolves a transit-agent session before falling
+    // through to the customer lookup. TransitAgentsModule is a leaf here — it
+    // does not import CompaniesModule — so no forwardRef is needed.
+    TransitAgentsModule,
   ],
   controllers: [CompaniesController],
   providers: [
diff --git a/apps/edr-freight-api/src/modules/companies/dto/account-info-response.dto.ts b/apps/edr-freight-api/src/modules/companies/dto/account-info-response.dto.ts
index ab680f8f3..9a43e65d4 100644
--- a/apps/edr-freight-api/src/modules/companies/dto/account-info-response.dto.ts
+++ b/apps/edr-freight-api/src/modules/companies/dto/account-info-response.dto.ts
@@ -1,6 +1,7 @@
 import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
 
 import { ShippingLineCompany } from "../../shipping-lines/entities/shipping-line-company.entity";
+import { TransitAgent } from "../../transit-agents/entities/transit-agent.entity";
 import { CompanyInfoResponseDto } from "./company-info-response.dto";
 
 /**
@@ -9,10 +10,10 @@ import { CompanyInfoResponseDto } from "./company-info-response.dto";
  * The portal keys its onboarding gate off this rather than off "is `company`
  * missing?": a failed or slow company fetch also leaves `company` empty, and
  * treating that as "no onboarding needed" would let customers skip onboarding
- * whenever the request failed. A shipping line is identified positively, and
- * anything else defaults to `customer`.
+ * whenever the request failed. A shipping line and a transit agent are each
+ * identified positively, and anything else defaults to `customer`.
  */
-export type AccountKind = "customer" | "shipping_line";
+export type AccountKind = "customer" | "shipping_line" | "transit_agent";
 
 /** The signed-in shipping line. No company, no profile, no onboarding. */
 export class ShippingLineInfoResponseDto {
@@ -61,6 +62,62 @@ export class ShippingLineInfoResponseDto {
   }
 }
 
+/**
+ * The signed-in transit agent. Like a shipping line: no company, no profile, no
+ * onboarding — but a separate account kind because the two share nothing beyond
+ * that, and the portal shows each a different (much smaller) set of tabs.
+ */
+export class TransitAgentInfoResponseDto {
+  @ApiProperty({ enum: ["transit_agent"] })
+  accountKind: "transit_agent" = "transit_agent";
+
+  @ApiProperty()
+  id: string;
+
+  @ApiProperty()
+  name: string;
+
+  @ApiPropertyOptional()
+  email?: string | null;
+
+  @ApiPropertyOptional()
+  phoneNumber?: string | null;
+
+  @ApiProperty()
+  isActive: boolean;
+
+  @ApiProperty({
+    description: "Start of the agent's validity window (yyyy-MM-dd)",
+  })
+  validFrom: string;
+
+  @ApiProperty({
+    description: "End of the agent's validity window (yyyy-MM-dd)",
+  })
+  validTo: string;
+
+  /** Always null — see {@link ShippingLineInfoResponseDto.company}. */
+  @ApiProperty({ nullable: true })
+  company: null = null;
+
+  @ApiProperty({ nullable: true })
+  profile: null = null;
+
+  @ApiProperty({ nullable: true })
+  review: null = null;
+
+  constructor(entity: TransitAgent) {
+    this.id = entity.id;
+    this.name = entity.name;
+    this.email = entity.email ?? null;
+    this.phoneNumber = entity.phoneNumber ?? null;
+    this.isActive = entity.isActive;
+    this.validFrom = entity.validFrom;
+    this.validTo = entity.validTo;
+  }
+}
+
 export type AccountInfoResponse =
   | (CompanyInfoResponseDto & { accountKind: "customer" })
-  | ShippingLineInfoResponseDto;
+  | ShippingLineInfoResponseDto
+  | TransitAgentInfoResponseDto;
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/contract-notifier.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
index 477724839..10b6afd37 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-notifier.service.ts
@@ -176,6 +176,18 @@ export class ContractNotifierService {
     this.inApp(c, 'Contract suspension lifted', msg);
   }
 
+  /**
+   * Backoffice cancelled the contract. Terminal — the customer is told they may
+   * submit a new contract with the same details if they still need the service.
+   */
+  cancelledByStaff(c: Contract, reason: string): void {
+    const msg =
+      `Your contract ${c.reference} has been cancelled. Reason: ${reason}. ` +
+      `If you still need this service you can submit a new contract request with the same details.`;
+    void this.notifyContact(c, msg, 'CANCELLED');
+    this.inApp(c, 'Contract cancelled', msg);
+  }
+
   /** Customer cancelled their own contract — staff-side record. */
   cancelledByCustomer(c: Contract, reason: string): void {
     this.inAppStaff(
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-pricing.lane-scope.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-pricing.lane-scope.spec.ts
index 96a8a26ac..c535c909e 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-pricing.lane-scope.spec.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-pricing.lane-scope.spec.ts
@@ -120,3 +120,34 @@ describe('contract base freight is priced on the contract lane only', () => {
     ]);
   });
 });
+
+describe('contract base freight ignores shipping-line rates', () => {
+  it("never prices a customer contract off a line's negotiated rate (CTR-2026-00049)", async () => {
+    // Both LIVE on the contract's own lane: the line rate sorted first and won,
+    // so the contract quoted 32 USD/wagon instead of the standard 1690.
+    const breakdown = await service([
+      rate({
+        containerTypeId: CT20,
+        rateValue: 32,
+        rateUnit: 'PER_WAGON',
+        shippingLineCompanyId: 'line-1',
+      }),
+      rate({ containerTypeId: CT20, rateValue: 1690, rateUnit: 'PER_WAGON' }),
+    ]).buildBreakdown(contract({}));
+    expect(breakdown.lineItems).toEqual([
+      expect.objectContaining({ code: 'CONTAINER_20FT', unitPrice: 1690 }),
+    ]);
+  });
+
+  it('blocks when the only rate on the lane belongs to a shipping line', async () => {
+    await expect(
+      service([
+        rate({
+          containerTypeId: CT20,
+          rateValue: 32,
+          shippingLineCompanyId: 'line-1',
+        }),
+      ]).buildBreakdown(contract({})),
+    ).rejects.toThrow(UnprocessableEntityException);
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-pricing.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-pricing.service.ts
index 0af09a5f8..04be6460f 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-pricing.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-pricing.service.ts
@@ -85,7 +85,15 @@ export class ContractPricingService {
    * commodity rate) — NO totals or quantities (doc §9.1).
    */
   async buildBreakdown(contract: Contract): Promise<ContractPricingBreakdown> {
-    const liveRates = await this.ratesService.findLiveRates();
+    // Contracts belong to a customer company — there is no shipping-line
+    // contract (no shipping_line_company_id on the entity), so a contract may
+    // only ever price off the standard rates. Without this filter a line's
+    // negotiated rate on the same lane matched first and the contract froze it
+    // for a customer: CTR-2026-00049 quoted a line's 32 USD/wagon 20ft and
+    // 23 USD/container 40ft instead of the standard 1690 / 1676.
+    const liveRates = (await this.ratesService.findLiveRates()).filter(
+      (r) => !r.shippingLineCompanyId,
+    );
     const currency = contract.paymentCurrency;
     const isEtb = currency === 'ETB';
     const usdToEtb = isEtb ? await this.exchangeService.getRate('USD', 'ETB') : 1;
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-staff-cancel.spec.ts b/apps/edr-freight-api/src/modules/contracts/contract-staff-cancel.spec.ts
new file mode 100644
index 000000000..06a406bf1
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/contracts/contract-staff-cancel.spec.ts
@@ -0,0 +1,113 @@
+import { ContractTransitionService } from './contract-transition.service';
+import type { Contract } from './entities/contract.entity';
+
+/**
+ * Staff cancel is terminal, so the rules that matter are: it needs its own
+ * permission (suspend must NOT imply it), it refuses to strand live shipments,
+ * it works on a suspended contract, and it cannot be applied twice.
+ */
+describe('ContractTransitionService — staff cancel', () => {
+  const contract = (over: Partial<Contract> = {}): Contract =>
+    ({
+      id: 'c-1',
+      reference: 'CTR-2026-00042',
+      companyId: 'co-1',
+      status: 'CONTRACT_ACTIVE',
+      freightType: 'CONTAINER',
+      ...over,
+    }) as Contract;
+
+  let current: Contract;
+  let repo: {
+    update: jest.Mock;
+    createReviewNote: jest.Mock;
+    countActiveBookings: jest.Mock;
+  };
+  let notifier: { cancelledByStaff: jest.Mock };
+  let service: ContractTransitionService;
+
+  const staff = {
+    permissions: [{ key: 'edr_freight_app:contracts:cancel' }],
+  };
+
+  beforeEach(() => {
+    current = contract();
+    repo = {
+      update: jest.fn().mockImplementation((_id: string, patch: object) => {
+        current = { ...current, ...patch } as Contract;
+        return Promise.resolve(current);
+      }),
+      createReviewNote: jest.fn().mockResolvedValue(undefined),
+      countActiveBookings: jest.fn().mockResolvedValue(0),
+    };
+    notifier = { cancelledByStaff: jest.fn() };
+    service = Object.create(
+      ContractTransitionService.prototype,
+    ) as ContractTransitionService;
+    Object.assign(service, {
+      contractsRepository: repo,
+      contractsService: { findById: () => Promise.resolve(current) },
+      notifier,
+    });
+  });
+
+  it('cancels, records the reason as a staff note, and notifies the customer', async () => {
+    await service.cancelByStaff('c-1', 'Duplicate request', 'staff-1', staff as never);
+
+    expect(repo.update).toHaveBeenCalledWith('c-1', {
+      status: 'CANCELLED',
+      statusBeforeSuspension: null,
+    });
+    expect(repo.createReviewNote).toHaveBeenCalledWith(
+      'c-1',
+      'Duplicate request',
+      'CANCELLATION',
+      'staff-1',
+      'STAFF',
+    );
+    expect(notifier.cancelledByStaff).toHaveBeenCalled();
+  });
+
+  it('cancels a suspended contract — freezing it is exactly when staff kill it', async () => {
+    current = contract({
+      status: 'SUSPENDED',
+      statusBeforeSuspension: 'CONTRACT_ACTIVE',
+    } as Partial<Contract>);
+
+    await service.cancelByStaff('c-1', 'Customer withdrew', 'staff-1', staff as never);
+
+    expect(repo.update).toHaveBeenCalledWith('c-1', {
+      status: 'CANCELLED',
+      statusBeforeSuspension: null,
+    });
+  });
+
+  it('refuses while a shipment is still running', async () => {
+    repo.countActiveBookings.mockResolvedValue(2);
+
+    await expect(
+      service.cancelByStaff('c-1', 'Change of plan', 'staff-1', staff as never),
+    ).rejects.toThrow('2 active shipments');
+    expect(repo.update).not.toHaveBeenCalled();
+  });
+
+  it('refuses to cancel an already-terminal contract', async () => {
+    current = contract({ status: 'CANCELLED' });
+
+    await expect(
+      service.cancelByStaff('c-1', 'Again', 'staff-1', staff as never),
+    ).rejects.toThrow(/already cancelled/i);
+    expect(repo.update).not.toHaveBeenCalled();
+  });
+
+  it('rejects a user holding only the suspend key — cancel is a separate permission', async () => {
+    const suspender = {
+      permissions: [{ key: 'edr_freight_app:contracts:suspend' }],
+    };
+
+    await expect(
+      service.cancelByStaff('c-1', 'Not allowed', 'staff-1', suspender as never),
+    ).rejects.toThrow();
+    expect(repo.update).not.toHaveBeenCalled();
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts b/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
index 936176f86..ac400d9d3 100644
--- a/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contract-transition.service.ts
@@ -1452,6 +1452,54 @@ export class ContractTransitionService {
     return updated;
   }
 
+  /**
+   * Staff cancel — terminal, unlike suspend. The contract is dead; a fresh one
+   * with the same parameters can be submitted afterwards (references are minted
+   * per contract, so nothing about the old row blocks the new one).
+   *
+   * Cancellable from ANY non-terminal status, including SUSPENDED: a frozen
+   * contract is exactly the one staff most often need to kill outright.
+   */
+  async cancelByStaff(
+    contractId: string,
+    reason: string,
+    actorId: string,
+    user?: TCurrentUser | null,
+  ): Promise<Contract> {
+    const contract = await this.contractsService.findById(contractId);
+    assertFreightPermission(user, FREIGHT_PERMS.contracts.cancel);
+    if ((TERMINAL_CONTRACT_STATUSES as readonly string[]).includes(contract.status)) {
+      throw new ConflictException(
+        `Contract is already ${contract.status.toLowerCase().replace(/_/g, ' ')}.`,
+      );
+    }
+
+    // Same guard as the customer path: live shipments must be settled first,
+    // otherwise cancelling the contract orphans cargo already in motion.
+    const active = await this.contractsRepository.countActiveBookings(contractId);
+    if (active > 0) {
+      throw new BadRequestException(
+        `This contract has ${active} active shipment${active === 1 ? '' : 's'}. ` +
+          'Cancel or complete them before cancelling the contract.',
+      );
+    }
+
+    await this.contractsRepository.createReviewNote(
+      contractId,
+      reason,
+      'CANCELLATION',
+      actorId,
+      'STAFF',
+    );
+    await this.contractsRepository.update(contractId, {
+      status: 'CANCELLED',
+      statusBeforeSuspension: null,
+    } as never);
+    const updated = await this.contractsService.findById(contractId);
+    this.notifier.cancelledByStaff(updated, reason);
+    return updated;
+  }
+
   async renew(contractId: string, userId?: string): Promise<Contract> {
     const source = await this.contractsService.findById(contractId);
 
diff --git a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
index 1dc083934..c38576fff 100644
--- a/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
+++ b/apps/edr-freight-api/src/modules/contracts/contracts.controller.ts
@@ -72,6 +72,7 @@ import {
   RequestChangesDto,
   ResumeContractDto,
   SuspendContractDto,
+  CancelContractByStaffDto,
 } from './dto/approve-step.dto';
 import { SignContractDto } from './dto/sign-contract.dto';
 import { ReviewClearanceDocumentDto } from './dto/review-clearance-document.dto';
@@ -552,6 +553,25 @@ export class ContractsController {
     );
   }
 
+  @Post(':id/staff/cancel')
+  @BookingStaff(FREIGHT_PERMS.contracts.cancel)
+  @ApiOperation({
+    summary:
+      'Staff cancel a contract (terminal — a new contract with the same details may be submitted after)',
+  })
+  cancelByStaff(
+    @Param('id', ParseUUIDPipe) id: string,
+    @Body() dto: CancelContractByStaffDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    return this.transitionService.cancelByStaff(
+      id,
+      dto.reason,
+      resolveAuthUserId(user),
+      user,
+    );
+  }
+
   @Post(':id/approval-steps/:stepId/approve')
   @BookingStaff(FREIGHT_PERMS.contracts.view)
   @ApiOperation({ summary: 'Approve one approval step in sequence' })
diff --git a/apps/edr-freight-api/src/modules/contracts/dto/approve-step.dto.ts b/apps/edr-freight-api/src/modules/contracts/dto/approve-step.dto.ts
index 6aa36b13d..63057978c 100644
--- a/apps/edr-freight-api/src/modules/contracts/dto/approve-step.dto.ts
+++ b/apps/edr-freight-api/src/modules/contracts/dto/approve-step.dto.ts
@@ -51,6 +51,14 @@ export class CancelContractDto {
   reason?: string;
 }
 
+/** Staff cancel is terminal, so the reason is mandatory — it is the audit record. */
+export class CancelContractByStaffDto {
+  @ApiProperty({ description: 'Why the contract is being cancelled — shown to the customer' })
+  @IsString()
+  @MinLength(1)
+  reason!: string;
+}
+
 export class SuspendContractDto {
   @ApiProperty({ description: 'Why the contract is being frozen — shown to the customer' })
   @IsString()
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/notifications/notify-company.util.ts b/apps/edr-freight-api/src/modules/notifications/notify-company.util.ts
index 467b172ba..1dd8ad9ca 100644
--- a/apps/edr-freight-api/src/modules/notifications/notify-company.util.ts
+++ b/apps/edr-freight-api/src/modules/notifications/notify-company.util.ts
@@ -83,3 +83,184 @@ export async function notifyCarriageAcceptanceReady(
     logger.warn(`Carriage acceptance ready notify failed for ${bookingId}: ${(err as Error).message}`);
   }
 }
+
+/** One container line on the load manifest notice. */
+interface LoadManifestLists {
+  reference: string;
+  companyId: string | null;
+  trainNumber: string | null;
+  originStation: string | null;
+  destinationStation: string | null;
+  departureAt: Date | null;
+  loaded: string[];
+  leftBehind: string[];
+}
+
+/** At most `max` numbers, then "+N more" — an SMS must not carry 44 of them. */
+function summarizeNumbers(numbers: string[], max = 5): string {
+  if (numbers.length === 0) return 'none';
+  const shown = numbers.slice(0, max).join(', ');
+  const rest = numbers.length - max;
+  return rest > 0 ? `${shown} +${rest} more` : shown;
+}
+
+/**
+ * Read what actually went on the train and what did not. Left behind = every
+ * container the customer declared minus the ones sitting on a LOADED/DEPARTED
+ * wagon, so a booking loaded in parts reports honestly on both halves.
+ */
+export async function loadManifestLists(
+  dataSource: DataSource,
+  bookingId: string,
+  trainScheduleId: string,
+): Promise<LoadManifestLists | null> {
+  const [booking]: Array<{ reference: string; companyId: string | null }> =
+    await dataSource.query(
+      `SELECT reference, company_id AS "companyId"
+         FROM freight.bookings
+        WHERE id = $1 AND deleted_at IS NULL`,
+      [bookingId],
+    );
+  if (!booking) return null;
+
+  const [train]: Array<{
+    trainNumber: string | null;
+    originStation: string | null;
+    destinationStation: string | null;
+    departureAt: Date | null;
+  }> = await dataSource.query(
+    `SELECT s.train_number              AS "trainNumber",
+            so.label                    AS "originStation",
+            sd.label                    AS "destinationStation",
+            s.scheduled_departure_date  AS "departureAt"
+       FROM freight.train_schedules s
+       LEFT JOIN freight.yards so ON so.id = s.origin_station_id
+       LEFT JOIN freight.yards sd ON sd.id = s.destination_station_id
+      WHERE s.id = $1 AND s.deleted_at IS NULL`,
+    [trainScheduleId],
+  );
+
+  const loadedRows: Array<{ containerNumber: string | null }> = await dataSource.query(
+    `SELECT DISTINCT ci.container_number AS "containerNumber"
+       FROM freight.wagon_allocation_container_items ci
+       JOIN freight.wagon_booking_allocations a
+         ON a.id = ci.wagon_booking_allocation_id AND a.deleted_at IS NULL
+      WHERE a.booking_id = $1
+        AND ci.deleted_at IS NULL
+        AND a.status IN ('LOADED', 'DEPARTED')
+      ORDER BY 1`,
+    [bookingId],
+  );
+  const declaredRows: Array<{ containerNumber: string | null }> = await dataSource.query(
+    `SELECT DISTINCT u.container_number AS "containerNumber"
+       FROM freight.booking_container_units u
+       JOIN freight.booking_container l
+         ON l.id = u.booking_container_id AND l.deleted_at IS NULL
+      WHERE l.booking_id = $1 AND u.deleted_at IS NULL
+      ORDER BY 1`,
+    [bookingId],
+  );
+
+  const loaded = loadedRows.map((r) => r.containerNumber).filter(Boolean) as string[];
+  const loadedSet = new Set(loaded);
+  const leftBehind = (declaredRows.map((r) => r.containerNumber).filter(Boolean) as string[]).filter(
+    (n) => !loadedSet.has(n),
+  );
+
+  return {
+    reference: booking.reference,
+    companyId: booking.companyId,
+    trainNumber: train?.trainNumber ?? null,
+    originStation: train?.originStation ?? null,
+    destinationStation: train?.destinationStation ?? null,
+    departureAt: train?.departureAt ?? null,
+    loaded,
+    leftBehind,
+  };
+}
+
+/**
+ * Tell the customer what boarded the train and what did not, over in-app + SMS
+ * + email, and raise a warehouse-desk notice for anything left behind so
+ * somebody owns finding it space. A booking is routinely loaded in parts, and
+ * before this the customer learnt about it only by reading the sheet.
+ *
+ * Best-effort throughout: loading must never roll back because a provider is
+ * down.
+ */
+export async function notifyLoadManifest(
+  dataSource: DataSource,
+  notifications: NotificationsService,
+  inbox: NotificationInboxService,
+  bookingId: string,
+  trainScheduleId: string,
+  warehouseNotificationPermission: string,
+  logger: Logger,
+): Promise<void> {
+  try {
+    const m = await loadManifestLists(dataSource, bookingId, trainScheduleId);
+    if (!m) return;
+
+    const route =
+      m.originStation && m.destinationStation
+        ? ` ${m.originStation} → ${m.destinationStation}`
+        : '';
+    const departs = m.departureAt
+      ? `, departs ${new Date(m.departureAt).toLocaleString('en-GB')}`
+      : '';
+    const train = m.trainNumber ? `train ${m.trainNumber}` : 'the train';
+
+    const headline =
+      `Booking ${m.reference}: ${m.loaded.length} container(s) loaded on ${train}` +
+      `${route}${departs}.`;
+    const loadedLine = m.loaded.length > 0 ? ` Loaded: ${summarizeNumbers(m.loaded)}.` : '';
+    const leftLine =
+      m.leftBehind.length > 0
+        ? ` Not loaded (${m.leftBehind.length}): ${summarizeNumbers(m.leftBehind)}.` +
+          ' These stay with EDR — once a warehouse is assigned you will receive the GRN.'
+        : '';
+    const body = headline + loadedLine + leftLine;
+
+    if (m.companyId) {
+      await inbox.notify({
+        recipients: { companyId: m.companyId },
+        audience: NotificationAudience.PORTAL,
+        type: NotificationType.BOOKING_STATUS,
+        title: m.leftBehind.length > 0 ? 'Cargo partly loaded' : 'Cargo loaded',
+        // The in-app copy carries every number; SMS and email get the summary.
+        body:
+          headline +
+          (m.loaded.length > 0 ? `\nLoaded: ${m.loaded.join(', ')}` : '') +
+          (m.leftBehind.length > 0
+            ? `\nNot loaded: ${m.leftBehind.join(', ')}\nThese stay with EDR — once a warehouse is assigned you will receive the GRN.`
+            : ''),
+        link: `/bookings/${bookingId}`,
+        data: {
+          bookingId,
+          reference: m.reference,
+          trainNumber: m.trainNumber,
+          loaded: m.loaded,
+          leftBehind: m.leftBehind,
+        },
+      });
+      await sendCompanyChannels(dataSource, notifications, m.companyId, body);
+    }
+
+    // Nothing left behind is nothing for the warehouse desk to place.
+    if (m.leftBehind.length > 0) {
+      await inbox.notify({
+        recipients: { permissionKeys: [warehouseNotificationPermission] },
+        audience: NotificationAudience.BACKOFFICE,
+        type: NotificationType.REQUEST_SUBMITTED,
+        title: `${m.leftBehind.length} container(s) left behind — ${m.reference}`,
+        body:
+          `${train} departed without ${m.leftBehind.length} container(s) of booking ${m.reference}: ` +
+          `${m.leftBehind.join(', ')}. Assign warehouse space and raise the GRN.`,
+        link: `/dashboard/booking-requests/${bookingId}`,
+        data: { bookingId, reference: m.reference, leftBehind: m.leftBehind },
+      });
+    }
+  } catch (err) {
+    logger.warn(`Load manifest notify failed for ${bookingId}: ${(err as Error).message}`);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/otp/otp.service.spec.ts b/apps/edr-freight-api/src/modules/otp/otp.service.spec.ts
index 00f8d107a..086baef66 100644
--- a/apps/edr-freight-api/src/modules/otp/otp.service.spec.ts
+++ b/apps/edr-freight-api/src/modules/otp/otp.service.spec.ts
@@ -35,9 +35,24 @@ describe("isDomesticPhone", () => {
     (phone) => expect(isDomesticPhone(phone)).toBe(true),
   );
 
-  it.each(["+14155550123", "+447911123456", "0712345678", "+2519866", "12345"])(
-    "rejects non-domestic or malformed %s",
-    (phone) => expect(isDomesticPhone(phone)).toBe(false),
+  // Djibouti is the line's other end: the gateway reaches its 77x mobiles.
+  it.each(["+25377123456", "25377123456", "77123456"])(
+    "accepts Djibouti mobile form %s",
+    (phone) => expect(isDomesticPhone(phone)).toBe(true),
+  );
+
+  it.each([
+    "+14155550123",
+    "+447911123456",
+    "0712345678",
+    "+2519866",
+    "12345",
+    // Djibouti fixed line (2x) — valid number, not a mobile the gateway serves.
+    "+25321350000",
+    // Right length, wrong Djibouti prefix.
+    "+25366123456",
+  ])("rejects unreachable or malformed %s", (phone) =>
+    expect(isDomesticPhone(phone)).toBe(false),
   );
 });
 
diff --git a/apps/edr-freight-api/src/modules/otp/otp.service.ts b/apps/edr-freight-api/src/modules/otp/otp.service.ts
index b27520c25..6b5a0e0d9 100644
--- a/apps/edr-freight-api/src/modules/otp/otp.service.ts
+++ b/apps/edr-freight-api/src/modules/otp/otp.service.ts
@@ -42,20 +42,42 @@ function normalizePhone(rawPhone: string): string {
   if (digits.startsWith("+")) return digits;
   const bare = digits.replace(/^0+/, "");
   if (/^251\d{9}$/.test(digits)) return `+${digits}`;
+  if (/^253\d{8}$/.test(digits)) return `+${digits}`;
   if (/^9\d{8}$|^7\d{8}$/.test(bare)) return `+251${bare}`;
+  // Djibouti mobiles are 8 digits starting 77 and have no trunk prefix, so a
+  // bare "77…" is unambiguous — it cannot be an Ethiopian local number, which
+  // is always 9 digits after the trunk zero.
+  if (/^77\d{6}$/.test(bare)) return `+253${bare}`;
   // Unknown shape (foreign number, already-clean intl without +) — prefix + if
   // it looks like a full international number, else leave as typed.
   return digits.length >= 11 ? `+${digits}` : raw;
 }
 
 /**
- * Whether a phone is an Ethiopian mobile the SMS gateway can actually reach —
- * the carrier integration is domestic-only, so a send to anything else is
- * queued and silently lost. Callers use this to fall back to email instead of
- * pretending an SMS is on its way.
+ * Mobile ranges the SMS gateway is contracted to reach, as E.164 patterns.
+ *
+ * The gateway itself is opaque from here — `SmsClientService` publishes to
+ * RabbitMQ and the carrier sits several hops downstream — so this list is a
+ * policy statement, not a capability probe: a number outside it is treated as
+ * unreachable and callers fall back to email rather than promising an SMS that
+ * would be queued and silently dropped.
+ *
+ * - Ethiopia: `+2519…` mobiles only. `+2517…` is deliberately absent; it parses
+ *   as a valid ET number but is not a range this gateway delivers to.
+ * - Djibouti: `+25377…`, the country's only mobile range (2x is fixed-line).
+ */
+const REACHABLE_MOBILE_PATTERNS = [/^\+2519\d{8}$/, /^\+25377\d{6}$/];
+
+/**
+ * Whether a phone sits in a mobile range the SMS gateway can actually reach.
+ *
+ * Named "domestic" for the Ethiopian-only era this predates; it now covers both
+ * countries the railway runs through. Callers use it to fall back to email
+ * instead of pretending an SMS is on its way.
  */
 export function isDomesticPhone(rawPhone: string): boolean {
-  return /^\+2519\d{8}$/.test(normalizePhone(rawPhone));
+  const normalized = normalizePhone(rawPhone);
+  return REACHABLE_MOBILE_PATTERNS.some((p) => p.test(normalized));
 }
 
 /**
@@ -99,7 +121,7 @@ export class OtpService {
     private readonly otpRepository: OtpRepository,
     private readonly notifications: NotificationsService,
     private readonly emailClient: EmailClientService,
-  ) { }
+  ) {}
 
   // ---------------------------------------------------------------------------
   // Generate OTP
@@ -197,8 +219,10 @@ export class OtpService {
 
       for (const outcome of outcomes) {
         this.logger.log(
-          `otp.dispatch channel=${outcome.channel} target=${label} queued=${outcome.queued
-          } latencyMs=${Date.now() - startedAt}${outcome.error ? ` error=${outcome.error}` : ""
+          `otp.dispatch channel=${outcome.channel} target=${label} queued=${
+            outcome.queued
+          } latencyMs=${Date.now() - startedAt}${
+            outcome.error ? ` error=${outcome.error}` : ""
           }`,
         );
       }
@@ -222,7 +246,8 @@ export class OtpService {
         // user who never receives a code — indistinguishable from carrier loss,
         // and the misleading success response makes it look like our side worked.
         this.logger.error(
-          `otp.dispatch.dropped channels=${channels.join("+")} target=${label} rabbitmqEnabled=${process.env.RABBITMQ_ENABLED ?? "unset"
+          `otp.dispatch.dropped channels=${channels.join("+")} target=${label} rabbitmqEnabled=${
+            process.env.RABBITMQ_ENABLED ?? "unset"
           } — no transport reported hand-off; no code will arrive for this send`,
         );
       }
@@ -247,7 +272,8 @@ export class OtpService {
       // Log the real cause (DB/SMS/email failure) with its stack so a deployed
       // "Failed to send OTP" 400 is diagnosable from the API logs, not opaque.
       this.logger.error(
-        `otp.dispatch.failed channels=${channels.join("+")} target=${label} latencyMs=${Date.now() - startedAt
+        `otp.dispatch.failed channels=${channels.join("+")} target=${label} latencyMs=${
+          Date.now() - startedAt
         }: ${error instanceof Error ? error.message : String(error)}`,
         error instanceof Error ? error.stack : undefined,
       );
@@ -330,8 +356,9 @@ export class OtpService {
   ) {
     const line = `otp.verify channels=${channelsOf(target).join(
       "+",
-    )} target=${this.targetLabel(target)} mode=${mode} result=${result}${detail ? ` ${detail}` : ""
-      }`;
+    )} target=${this.targetLabel(target)} mode=${mode} result=${result}${
+      detail ? ` ${detail}` : ""
+    }`;
     if (result === "ok") this.logger.log(line);
     else this.logger.warn(line);
 
diff --git a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
index 3fbecc036..f035f8a64 100644
--- a/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
+++ b/apps/edr-freight-api/src/modules/rule-engine/rule-engine.service.ts
@@ -508,12 +508,12 @@ export class RuleEngineService {
 
     if (input.tradeDirection === 'IMPORT') {
       appliedModifiers.push(
-        ...this.derivedImportOverweight(
+        ...(await this.derivedImportOverweight(
           input,
           containerWeightResults,
           lineMaxVgmTons,
           liveRates,
-        ),
+        )),
       );
     }
 
@@ -540,23 +540,37 @@ export class RuleEngineService {
   }
 
   /**
-   * Import overweight — derived, never configured. Each overweight container
-   * line bills its excess tons at (its own base import freight on the booking's
-   * route) ÷ (2 × its weight limit): 20ft at 1000 USD with a 20 t limit →
-   * 25 USD per excess ton. Export keeps the configured OVERWEIGHT rate.
-   * Note: derives from the LIVE route rate even for frozen-rate contract
-   * bookings — the frozen snapshot has no route-scoped container price to
-   * divide.
+   * Import overweight — derived, never configured. Excess tons are billed on a
+   * PER-WAGON basis: (the wagon's base import freight on the booking's route)
+   * ÷ (2 × the container's weight limit).
+   *
+   * The rate is normalised to a wagon before dividing, because a 20ft rate
+   * quoted PER_CONTAINER prices only HALF a wagon — two 20ft ride one wagon —
+   * while a 40ft container IS the whole wagon. So a PER_CONTAINER 20ft rate is
+   * doubled first; 40ft (and any rate already quoted PER_WAGON) is taken as is:
+   *   - 20ft PER_CONTAINER 845 USD, 20 t limit → (845 × 2) / (2 × 20) = 42.25
+   *   - 40ft PER_CONTAINER 1676 USD, 40 t limit → 1676 / (2 × 40) = 20.95
+   * Halving over 2 × the limit keeps the original meaning: filling one wagon's
+   * worth of excess costs one extra wagon of freight.
+   *
+   * Export keeps the configured OVERWEIGHT rate. Note: derives from the LIVE
+   * route rate even for frozen-rate contract bookings — the frozen snapshot has
+   * no route-scoped container price to divide.
    */
-  private derivedImportOverweight(
+  private async derivedImportOverweight(
     input: BookingEvaluationInput,
     weightResults: ContainerWeightResult[],
     lineMaxVgmTons: Array<number | null>,
     liveRates: Rate[],
-  ): AppliedCargoModifier[] {
+  ): Promise<AppliedCargoModifier[]> {
     const modifiers: AppliedCargoModifier[] = [];
     if (!input.originYardId || !input.destinationYardId) return modifiers;
 
+    // How many of each container type ride one wagon: a 40ft fills a wagon,
+    // two 20ft share one. Keyed by container type so a PER_CONTAINER rate can
+    // be scaled up to the wagon the overweight formula prices against.
+    const sizeByTypeId = await this.containersPerWagonByTypeId(weightResults);
+
     for (let i = 0; i < weightResults.length; i++) {
       const wr = weightResults[i];
       const excess = Number(wr?.overweightExcessTons ?? 0);
@@ -578,7 +592,16 @@ export class RuleEngineService {
       // No base rate → the base-freight line hard-blocks this booking anyway.
       if (!base) continue;
 
-      const perTon = Number(base.rateValue) / (2 * maxVgm);
+      // Normalise the rate to ONE WAGON before dividing. A PER_CONTAINER 20ft
+      // rate covers half a wagon, so it is scaled by the 2 containers that ride
+      // one; 40ft scales by 1. A rate already quoted PER_WAGON is the wagon
+      // price already — never scale it again.
+      const perWagonRate =
+        base.rateUnit === 'PER_CONTAINER'
+          ? Number(base.rateValue) * (sizeByTypeId.get(wr.containerTypeId) ?? 1)
+          : Number(base.rateValue);
+
+      const perTon = perWagonRate / (2 * maxVgm);
       const amount = excess * perTon;
       if (!(amount > 0)) continue;
 
@@ -595,6 +618,42 @@ export class RuleEngineService {
     return modifiers;
   }
 
+  /**
+   * Containers of each type that ride ONE wagon, derived from the type's
+   * size_ft against a 40ft wagon slot: 20ft → 2, 40ft → 1. Only the types the
+   * caller actually needs are looked up. Unknown or non-positive sizes fall
+   * back to 1, which leaves a PER_CONTAINER rate unscaled — the pre-existing
+   * behaviour, so a missing size can never inflate a bill.
+   */
+  private async containersPerWagonByTypeId(
+    weightResults: ContainerWeightResult[],
+  ): Promise<Map<string, number>> {
+    const perWagon = new Map<string, number>();
+    const ids = [...new Set(weightResults.map((w) => w.containerTypeId).filter(Boolean))];
+    if (ids.length === 0) return perWagon;
+
+    let rows: Array<{ id: string; size_ft: string | number | null }> = [];
+    try {
+      rows = await this.dataSource.query(
+        'SELECT id, size_ft FROM freight.container_types WHERE id = ANY($1)',
+        [ids],
+      );
+    } catch {
+      // Size lookup unavailable — fall back to an unscaled (×1) rate, the
+      // behaviour before per-wagon normalisation. Never fail pricing over it.
+      return perWagon;
+    }
+    const WAGON_SLOT_FT = 40;
+    for (const row of rows) {
+      const sizeFt = Number(row.size_ft ?? 0);
+      perWagon.set(
+        row.id,
+        sizeFt > 0 ? Math.max(1, Math.floor(WAGON_SLOT_FT / sizeFt)) : 1,
+      );
+    }
+    return perWagon;
+  }
+
   /**
    * Empty-container return — sold per direction + route + container type, like
    * base freight. Each container line that opted in (returnQuantity, or every
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 bf9c0aa5f..d9bae156a 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
@@ -3967,6 +3967,11 @@ export class BookingBatchService implements OnModuleInit {
         schedulingStatus: "SCHEDULED",
         scheduledAt: new Date(),
         wagonsRequired,
+        // Pinned for cancellation pricing: unassign clears wagonsRequired, this
+        // stays. Written once — a later re-allocation keeps the first stamp.
+        ...(Number(booking.cancellationWagons ?? 0) > 0
+          ? {}
+          : { cancellationWagons: wagonsRequired }),
         paymentDeadline: null,
         selectedForBatchAt: null,
       } as never);
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
index 07de05853..46cbdb2f6 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-journey.service.ts
@@ -31,7 +31,11 @@ import { TrainCheckpointEvent } from './entities/train-checkpoint-event.entity';
 import { assertExportReceivedWithGrn, DIRECT_TO_TRAIN } from '../../common/export-received-gate';
 import { NotificationsService } from '../notifications/notifications.service';
 import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
-import { notifyCarriageAcceptanceReady } from '../notifications/notify-company.util';
+import {
+  notifyCarriageAcceptanceReady,
+  notifyLoadManifest,
+} from '../notifications/notify-company.util';
+import { FREIGHT_PERMS } from '../../seed/freight-permissions.registry';
 
 /**
  * Per-booking journey along a train's corridor — for EVERY trade direction.
@@ -267,6 +271,20 @@ export class BookingJourneyService {
       });
     });
 
+    // What actually boarded, and what did not. A booking is routinely loaded in
+    // parts; the customer is told both halves, and the warehouse desk is told
+    // about the leftovers so somebody owns placing them. After the transaction:
+    // the lists are read back from the allocation statuses it just wrote.
+    void notifyLoadManifest(
+      this.dataSource,
+      this.notifications,
+      this.inbox,
+      bookingId,
+      scheduleId,
+      FREIGHT_PERMS.warehouseInventory.getNotification,
+      this.logger,
+    );
+
     // Customer tracking: cargo is on the train — loading milestones plus the
     // direction's "departed" handoff. Doc-trigger path no-ops non-customs
     // bookings (intercity) and already-completed codes.
diff --git a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
index 1c2d99401..4600f7f38 100644
--- a/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
+++ b/apps/edr-freight-api/src/modules/train-scheduling/booking-notifier.service.ts
@@ -39,15 +39,30 @@ export class BookingNotifierService {
     try {
       const s = await this.trainSchedules.findByIdWithStations(scheduleId);
       if (!s) return fallback;
-      const ref = s.reference ?? s.trainNumber ?? null;
-      const route =
+      // Customers know the train by its operating number (8001), not the
+      // schedule reference — lead with it and keep S-… as the secondary id.
+      const parts = [
+        s.reference,
         s.originStation?.label && s.destinationStation?.label
-          ? ` (${s.originStation.label} → ${s.destinationStation.label})`
-          : '';
+          ? `${s.originStation.label} → ${s.destinationStation.label}`
+          : null,
+      ].filter(Boolean);
+      const detail = parts.length ? ` (${parts.join(', ')})` : '';
       const departure = s.scheduledDepartureDate
-        ? `, departing ${new Date(s.scheduledDepartureDate).toLocaleDateString('en-GB', { timeZone: BATCH_TIMEZONE })}`
+        ? `, departing ${new Date(s.scheduledDepartureDate).toLocaleString('en-GB', {
+            timeZone: BATCH_TIMEZONE,
+            day: '2-digit',
+            month: '2-digit',
+            year: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+            hour12: false,
+          })} EAT`
         : '';
-      return ref ? `train ${ref}${route}${departure}` : `${fallback}${route}${departure}`;
+      const number = s.trainNumber ?? s.reference ?? null;
+      return number
+        ? `train ${number}${number === s.reference ? '' : detail}${departure}`
+        : `${fallback}${detail}${departure}`;
     } catch (err) {
       this.logger.warn(
         `scheduleLabel(${scheduleId}) failed: ${(err as Error).message}`,
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 d6e778216..64af1a56f 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
@@ -1134,7 +1134,7 @@ describe('TrainSchedulingService', () => {
       expect(html).toContain('2 (1 empty)');
     });
 
-    it('marks a leg slot on the import document as TO BE LOADED and keeps it out of the loaded tallies', () => {
+    it('drops a leg slot entirely from the import document — not part of the departing consist', () => {
       const loadList = {
         generatedAt: '2026-07-17T08:00:00.000Z',
         trainScheduleId: 'schedule-1',
@@ -1176,15 +1176,16 @@ describe('TrainSchedulingService', () => {
         buildImportLoadListHtml: (l: unknown) => string;
       }).buildImportLoadListHtml(loadList);
 
-      expect(html).toContain('TO BE LOADED AT DIRE DAWA PORT');
-      // Departure station of the leg slot is its board yard, not the origin.
-      expect(html).toContain('<td>Dire Dawa Port</td>');
-      // Only the origin-loaded container counts; the leg slot's tallies separately.
+      // The leg slot (W-ICY, boards later at Dire Dawa) gets no row at all —
+      // it isn't on the departing consist. Only W-IMP appears.
+      expect(html).not.toContain('W-ICY');
+      expect(html).not.toContain('ICY-001');
+      expect(html).toContain('W-IMP');
+      expect(html).toContain('<span>Wagons</span><strong>1</strong>');
       expect(html).toContain('<span>Total containers</span><strong>1</strong>');
-      expect(html).toContain('<span>To load en route</span><strong>1 containers</strong>');
     });
 
-    it('marks a leg slot on the export document as TO LOAD AT its board yard and keeps it out of the tallies', () => {
+    it('drops a leg slot entirely from the export document — not part of the departing consist', () => {
       const sizedAllocation = {
         ...loadedAllocation,
         containerItems: [{ containerNumber: 'CONT-001', containerType: { sizeFt: 20 } }],
@@ -1204,9 +1205,10 @@ describe('TrainSchedulingService', () => {
         pendingBoardYardLabelBySlot: new Map([['slot-leg', 'Dire Dawa Port']]),
       });
 
-      expect(html).toContain('TO LOAD AT DIRE DAWA PORT');
+      // The leg slot (W-LEG, boards later at Dire Dawa) gets no row at all.
+      expect(html).not.toContain('W-LEG');
+      expect(html).toContain('<span>Wagons</span><strong>1</strong>');
       expect(html).toContain('<span>Total containers</span><strong>1</strong>');
-      expect(html).toContain('<span>To load en route</span><strong>1 containers</strong>');
     });
 
     it('prints the consist-changes table for this stop, and omits it when there are none', () => {
@@ -1240,6 +1242,44 @@ describe('TrainSchedulingService', () => {
       expect(withoutChanges).not.toContain('Consist Changed At This Stop');
     });
 
+    it('shows per-row Departure/Arrival Station — schedule endpoints for a whole-route wagon, its own board/alight yard for a leg slot', () => {
+      const wholeRoute = { ...makeWagon(1, 'W-001', [loadedAllocation]), id: 'slot-1' };
+      const legSlot = {
+        ...makeWagon(2, 'W-LEG', [loadedAllocation]),
+        id: 'slot-leg',
+        boardYardId: 'yard-dire',
+        alightYardId: 'yard-adama',
+      };
+      const schedule = {
+        id: 'schedule-1',
+        trainNumber: '8302',
+        direction: 'EXPORT',
+        originStation: { label: 'DCT/SGTD' },
+        destinationStation: { label: 'GMP (Gelan Multipurpose Port)' },
+        trainSet: { wagons: [wholeRoute, legSlot] },
+        scheduleBookings: [],
+      };
+      const build = (service as never as {
+        buildExportLoadListHtml: (s: unknown, o?: unknown) => string;
+      }).buildExportLoadListHtml.bind(service);
+
+      const html = build(schedule, {
+        yardLabelById: new Map([
+          ['yard-dire', 'Dire Dawa Port'],
+          ['yard-adama', 'Adama'],
+        ]),
+      });
+
+      expect(html).toContain('<th>Departure Station</th>');
+      expect(html).toContain('<th>Arrival Station</th>');
+      // Whole-route wagon: schedule's own endpoints.
+      expect(html).toContain('<td>DCT/SGTD</td>');
+      expect(html).toContain('<td>GMP (Gelan Multipurpose Port)</td>');
+      // Leg slot: its own board/alight yard, not the schedule's endpoints.
+      expect(html).toContain('<td>Dire Dawa Port</td>');
+      expect(html).toContain('<td>Adama</td>');
+    });
+
     it('lists loaded empty containers by number and states they are empty', () => {
       const schedule = {
         id: 'schedule-1',
@@ -1404,6 +1444,30 @@ describe('TrainSchedulingService', () => {
       expect(numbers).toEqual(['W-LEG2']);
     });
 
+    it('drops a leg slot LOADED by generation time but not yet coupled as of this stop', () => {
+      // Both W-DIRE (coupled+loaded at Dire Dawa) and W-ADAMA (coupled+loaded
+      // at Adama, a LATER stop) read identically to intercityOnBoardView by
+      // the time this runs — both LOADED right now. Only the adjustment log
+      // knows W-ADAMA hadn't coupled yet as of Dire Dawa's own timestamp.
+      const wholeRoute = makeWagon(1, 'W-001', [allocWith({ status: 'LOADED' })]);
+      const legDireDawa = { ...makeWagon(2, 'W-DIRE', [allocWith({ status: 'LOADED' })]), boardYardId: 'yard-dire' };
+      const legAdama = { ...makeWagon(3, 'W-ADAMA', [allocWith({ status: 'LOADED' })]), boardYardId: 'yard-adama' };
+      const schedule = { trainSet: { wagons: [wholeRoute, legDireDawa, legAdama] }, scheduleBookings: [] };
+
+      const { wagons } = onBoardView(schedule);
+      const boardedByDireDawa = new Set(['W-DIRE']); // logged ADD only up to Dire Dawa's stop
+      const wagonsAsOfStop = (service as never as {
+        wagonsAsOfStop: (w: unknown, s: Set<string>) => Array<{ physicalWagon: { wagonNumber: string } }>;
+      }).wagonsAsOfStop.bind(service);
+
+      const asOfDireDawa = wagonsAsOfStop(wagons, boardedByDireDawa);
+      expect(asOfDireDawa.map((w) => w.physicalWagon.wagonNumber)).toEqual(['W-001', 'W-DIRE']);
+
+      const boardedByAdama = new Set(['W-DIRE', 'W-ADAMA']); // both stops have now happened
+      const asOfAdama = wagonsAsOfStop(wagons, boardedByAdama);
+      expect(asOfAdama.map((w) => w.physicalWagon.wagonNumber)).toEqual(['W-001', 'W-DIRE', 'W-ADAMA']);
+    });
+
     it('lists an IN_TRANSIT booking with no wagon allocation in the unassigned section', () => {
       const rider = {
         id: 'booking-9',
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 dbf0c7f7c..07d386df3 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
@@ -28,6 +28,7 @@ import {
   ILike,
   In,
   IsNull,
+  LessThanOrEqual,
   Not,
   QueryFailedError,
   Raw,
@@ -2320,12 +2321,18 @@ export class TrainSchedulingService {
       // batch fill, which unlinks it and frees its wagons on the next window cycle.
       const scheduledAt = new Date();
       for (const booking of bookings) {
+        const wagonsRequired = sumWagonsRequired(booking, wagonPlan);
         await this.bookingsRepository.updateSchedulingFields(
           booking.id,
           {
             schedulingStatus: SchedulingStatus.Scheduled,
             scheduledAt,
-            wagonsRequired: sumWagonsRequired(booking, wagonPlan),
+            wagonsRequired,
+            // Pinned for cancellation pricing: unassign clears wagonsRequired,
+            // this stays. Written once — re-allocation keeps the first stamp.
+            ...(Number(booking.cancellationWagons ?? 0) > 0
+              ? {}
+              : { cancellationWagons: wagonsRequired }),
           },
           manager,
         );
@@ -3550,17 +3557,19 @@ export class TrainSchedulingService {
 
     // Leg slots couple mid-corridor — this origin document must say where their
     // cargo boards instead of listing it as loaded here (see the import list).
-    const slotYardLabels = await this.yardLabelsById(
-      (schedule.trainSet?.wagons ?? []).map((wagon) => wagon.boardYardId),
+    // Also doubles as the per-row Departure/Arrival Station lookup below.
+    const yardLabelById = await this.yardLabelsById(
+      (schedule.trainSet?.wagons ?? []).flatMap((wagon) => [wagon.boardYardId, wagon.alightYardId]),
     );
     const pendingBoardYardLabelBySlot = new Map(
       (schedule.trainSet?.wagons ?? [])
         .filter((wagon) => wagon.boardYardId)
-        .map((wagon) => [wagon.id, slotYardLabels.get(wagon.boardYardId!) ?? 'en route']),
+        .map((wagon) => [wagon.id, yardLabelById.get(wagon.boardYardId!) ?? 'en route']),
     );
 
     const html = this.buildExportLoadListHtml(schedule, {
       pendingBoardYardLabelBySlot,
+      yardLabelById,
       emptyContainers: await this.loadedEmptyContainers(scheduleId),
       logoImageUrl: await this.logoSettings.getLogoImageUrl(),
     });
@@ -3617,6 +3626,24 @@ export class TrainSchedulingService {
     return { wagons, unassignedBookings };
   }
 
+  /**
+   * Corrects intercityOnBoardView's CURRENT-state wagon list against a
+   * specific stop's document. intercityOnBoardView's "boardYardId == null ||
+   * hasLoaded" test reads whatever is true RIGHT NOW — it can't distinguish
+   * "this leg slot coupled at THIS stop" from "it coupled at a LATER stop
+   * that has, by generation time, also already happened" (both look LOADED).
+   * Reprinting an earlier stop's document after a later one has run would
+   * otherwise leak the later stop's wagons in. `boardedWagonNumbers` is the
+   * set of physical wagon numbers with a logged ADD at or before this stop
+   * (see marshallingDocumentAt) — the ground truth a real-time heuristic
+   * can't provide once multiple stops have already happened.
+   */
+  private wagonsAsOfStop(wagons: TrainSetWagon[], boardedWagonNumbers: Set<string>): TrainSetWagon[] {
+    return wagons.filter(
+      (wagon) => wagon.boardYardId == null || boardedWagonNumbers.has(wagon.physicalWagon?.wagonNumber ?? ''),
+    );
+  }
+
   /**
    * Every corridor stop where the consist actually changed for this schedule
    * (coupled, uncoupled, or switched — any flavor), in the order the train
@@ -3711,11 +3738,37 @@ export class TrainSchedulingService {
       );
     }
 
-    const { wagons, unassignedBookings } = this.intercityOnBoardView(schedule);
+    const { wagons: currentWagons, unassignedBookings } = this.intercityOnBoardView(schedule);
+    // intercityOnBoardView's "boardYardId == null || hasLoaded" test reads
+    // CURRENT state — it can't tell "coupled here" from "coupled at a LATER
+    // stop that has since also happened" (both look LOADED by generation
+    // time once the trip has moved past this stop). Reprinting Marshalling 2
+    // after Marshalling 3's stop already ran would otherwise show Marshalling
+    // 3's coupled wagons too. Correct it against the log: a leg-slot wagon
+    // belongs on THIS stop's document only if it actually has a logged ADD
+    // at or before THIS stop's own timestamp.
+    const boardedByThisStop = new Set(
+      (
+        await this.dataSource.getRepository(ScheduleWagonAdjustmentLog).find({
+          where: {
+            trainScheduleId: scheduleId,
+            action: 'ADD',
+            occurredAt: LessThanOrEqual(new Date(stop.firstOccurredAt)),
+          },
+        })
+      ).map((row) => row.wagonNumber),
+    );
+    const wagons = this.wagonsAsOfStop(currentWagons, boardedByThisStop);
     const logRows = await this.dataSource.getRepository(ScheduleWagonAdjustmentLog).find({
       where: { trainScheduleId: scheduleId, yardId: stop.yardId },
       order: { occurredAt: 'ASC' },
     });
+    // Per-row Departure/Arrival Station: a whole-route wagon reads the
+    // schedule's own origin/destination, a leg-slot wagon reads where IT
+    // boards/alights instead.
+    const yardLabelById = await this.yardLabelsById(
+      (schedule.trainSet?.wagons ?? []).flatMap((wagon) => [wagon.boardYardId, wagon.alightYardId]),
+    );
     const html = this.buildExportLoadListHtml(schedule, {
       title: `Intercity Marshalling Document / Load List (Marshalling ${stopIndex})`,
       positionLabel: `At ${stop.yardLabel}`,
@@ -3724,6 +3777,7 @@ export class TrainSchedulingService {
       emptyContainers: await this.loadedEmptyContainers(scheduleId),
       logoImageUrl: await this.logoSettings.getLogoImageUrl(),
       consistChangesAtStop: this.consistChangesAt(schedule, logRows),
+      yardLabelById,
     });
     // Styled table-aware fallback (marshalling grid) — see importLoadListDocument.
     const buffer = await this.pdfDocuments.renderTabularDocument(html, `Marshalling ${stopIndex}`);
@@ -3763,6 +3817,9 @@ export class TrainSchedulingService {
       ? `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);
+    const yardLabelById = await this.yardLabelsById(
+      (schedule.trainSet?.wagons ?? []).flatMap((wagon) => [wagon.boardYardId, wagon.alightYardId]),
+    );
     const html = this.buildExportLoadListHtml(schedule, {
       title: 'Intercity Marshalling Document / Load List (Marshalling 2)',
       positionLabel,
@@ -3770,6 +3827,7 @@ export class TrainSchedulingService {
       unassignedBookings,
       emptyContainers: await this.loadedEmptyContainers(scheduleId),
       logoImageUrl: await this.logoSettings.getLogoImageUrl(),
+      yardLabelById,
     });
     // Styled table-aware fallback (marshalling grid) — see importLoadListDocument.
     const buffer = await this.pdfDocuments.renderTabularDocument(html, 'Intercity marshalling / load list');
@@ -3839,6 +3897,10 @@ 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>;
+      // yardId → label, for the per-row Departure/Arrival Station columns
+      // (falls back to the schedule's own origin/destination when a wagon's
+      // boardYardId/alightYardId is null — i.e. it rides the whole corridor).
+      yardLabelById?: Map<string, string>;
       // 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.
@@ -3860,10 +3922,15 @@ export class TrainSchedulingService {
     const time = (value: unknown) => (value ? new Date(value as string | Date).toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' }) : '-');
     const bookingById = new Map((schedule.scheduleBookings ?? []).map((link) => [link.bookingId, link.booking]));
     // The document is checked against the physical train, so it has to run in
-    // consist order — the relation comes back unordered.
-    const wagons = [...(opts?.wagons ?? schedule.trainSet?.wagons ?? [])].sort(
-      (a, b) => Number(a.sequenceNo ?? 0) - Number(b.sequenceNo ?? 0),
-    );
+    // consist order — the relation comes back unordered. Slots planned to
+    // couple at a LATER stop (pendingBoardYardLabelBySlot, origin docs only —
+    // intercity calls never pass it, their wagons list is already on-board
+    // only) are dropped here, not just tallied around: they are not part of
+    // the departing consist, so they get no row and no count on this document.
+    // Their own coupling shows up on THAT stop's own marshalling document.
+    const wagons = [...(opts?.wagons ?? schedule.trainSet?.wagons ?? [])]
+      .filter((wagon) => !opts?.pendingBoardYardLabelBySlot?.get(wagon.id))
+      .sort((a, b) => Number(a.sequenceNo ?? 0) - Number(b.sequenceNo ?? 0));
     // Empties sit on wagons that carry no booking allocation, keyed by the wagon
     // slot recorded when they were loaded.
     const emptiesByWagon = new Map<number, EmptyContainerReturn[]>();
@@ -3874,15 +3941,28 @@ export class TrainSchedulingService {
         empty,
       ]);
     }
+    const originLabel = schedule.originStation?.label ?? schedule.originStation?.code;
+    const destinationLabel = schedule.destinationStation?.label ?? schedule.destinationStation?.code;
     const rows = wagons
       .flatMap((wagon) => {
+        // Departure/Arrival Station per row: a leg-slot wagon boards/alights
+        // somewhere other than the schedule's own endpoints; a whole-route
+        // wagon just reads origin/destination.
+        const departureLabel = wagon.boardYardId
+          ? (opts?.yardLabelById?.get(wagon.boardYardId) ?? 'en route')
+          : originLabel;
+        const arrivalLabel = wagon.alightYardId
+          ? (opts?.yardLabelById?.get(wagon.alightYardId) ?? 'en route')
+          : destinationLabel;
         // Wagon identity is the same on every row the wagon produces, loaded or not.
         const wagonCells = `<td>${esc(wagon.sequenceNo)}</td>
             <td>${esc(wagon.physicalWagon?.wagonNumber)}</td>
             <td>${esc(wagon.wagonType?.code ?? wagon.wagonType?.name)}</td>
             <td class="num">${esc(Number(wagon.lengthMeters || 0).toFixed(3))}</td>
             <td class="num">${esc(Number(wagon.wagonType?.tareWeightTons ?? 0).toFixed(2))}</td>
-            <td class="num">${esc(Number(wagon.capacityTons || 0).toFixed(3))}</td>`;
+            <td class="num">${esc(Number(wagon.capacityTons || 0).toFixed(3))}</td>
+            <td>${esc(departureLabel)}</td>
+            <td>${esc(arrivalLabel)}</td>`;
         const allocations = wagon.allocations ?? [];
         // An empty wagon still runs in the consist, so it still gets a line. Staff
         // check this document against the physical train — a wagon with no row
@@ -3906,11 +3986,10 @@ export class TrainSchedulingService {
           return [
             `<tr class="empty">
             ${wagonCells}
-            <td colspan="4">EMPTY — no cargo allocated</td>
+            <td colspan="5">EMPTY — no cargo allocated</td>
           </tr>`,
           ];
         }
-        const pendingAt = opts?.pendingBoardYardLabelBySlot?.get(wagon.id);
         return allocations.map((allocation) => {
           const booking = allocation.booking ?? bookingById.get(allocation.bookingId);
           const cargoType = (booking as unknown as { cargoType?: { name?: string; code?: string } } | undefined)?.cargoType;
@@ -3922,7 +4001,7 @@ export class TrainSchedulingService {
           const chassisNumbers = containerItems.map((item) => item.chassisNumber).filter(Boolean).join(', ');
           return `<tr>
             ${wagonCells}
-            <td>${pendingAt ? `TO LOAD AT ${esc(pendingAt).toUpperCase()} — ` : ''}${esc(cargoType?.name ?? cargoType?.code ?? allocation.loadType)}</td>
+            <td>${esc(cargoType?.name ?? cargoType?.code ?? allocation.loadType)}</td>
             <td>${esc(companyName)}</td>
             <td>${esc(containerNumbers || firstContainer?.containerNumber)}</td>
             <td>${esc(chassisNumbers)}</td>
@@ -3935,7 +4014,7 @@ export class TrainSchedulingService {
     // they are still physically on the train, so they get rows of their own.
     const unassigned = opts?.unassignedBookings ?? [];
     const unassignedRows = unassigned.length
-      ? `<tr class="empty"><td colspan="11">ON BOARD — WAGON NOT RECORDED</td></tr>` +
+      ? `<tr class="empty"><td colspan="13">ON BOARD — WAGON NOT RECORDED</td></tr>` +
         unassigned
           .map((booking) => {
             const containerNumbers = (booking.bookingContainers ?? [])
@@ -3944,7 +4023,7 @@ export class TrainSchedulingService {
               .join(', ');
             const leg = `${booking.originYard?.label ?? booking.originYard?.code ?? '-'} → ${booking.destinationYard?.label ?? booking.destinationYard?.code ?? '-'}`;
             return `<tr>
-            <td colspan="6">${esc(booking.reference)} — ${esc(leg)}</td>
+            <td colspan="8">${esc(booking.reference)} — ${esc(leg)}</td>
             <td>${esc(booking.cargoType?.cargoTypeName ?? booking.cargoType?.code)}</td>
             <td>${esc(booking.company?.name)}</td>
             <td>${esc(containerNumbers)}</td>
@@ -3959,27 +4038,20 @@ export class TrainSchedulingService {
         (wagon.allocations ?? []).length === 0 &&
         !emptiesByWagon.get(Number(wagon.sequenceNo))?.length,
     ).length;
-    const loadsHere = (wagon: TrainSetWagon) => !opts?.pendingBoardYardLabelBySlot?.get(wagon.id);
     const totalWeight = wagons.reduce(
       (sum, wagon) =>
-        sum +
-        (loadsHere(wagon)
-          ? (wagon.allocations ?? []).reduce((wagonSum, allocation) => wagonSum + Number(allocation.allocatedWeightTons || 0), 0)
-          : 0),
+        sum + (wagon.allocations ?? []).reduce((wagonSum, allocation) => wagonSum + Number(allocation.allocatedWeightTons || 0), 0),
       0,
     );
 
     // Container count summary (40ft, 20ft) — empties returning to Djibouti are
-    // physically on the train, so they count, and are called out on their own tile.
-    // Cargo boarding downstream is not on this train yet — it tallies separately.
-    let count40ft = 0, count20ft = 0, pendingContainers = 0;
+    // physically on the train, so they count, and are called out on their own
+    // tile. Cargo boarding downstream never enters this loop — `wagons` above
+    // already excludes those slots.
+    let count40ft = 0, count20ft = 0;
     wagons.forEach((wagon) => {
       (wagon.allocations ?? []).forEach((allocation) => {
         (allocation.containerItems ?? []).forEach((item) => {
-          if (!loadsHere(wagon)) {
-            pendingContainers++;
-            return;
-          }
           const size = this.resolveContainerItemSize(item);
           if (size === 40) count40ft++;
           else if (size === 20) count20ft++;
@@ -4047,7 +4119,6 @@ export class TrainSchedulingService {
     <div class="tile"><span>Containers 40ft</span><strong>${esc(count40ft)}</strong></div>
     <div class="tile"><span>Containers 20ft</span><strong>${esc(count20ft)}</strong></div>
     <div class="tile"><span>Total containers</span><strong>${esc(count40ft + count20ft)}</strong></div>
-    ${pendingContainers ? `<div class="tile"><span>To load en route</span><strong>${esc(pendingContainers)} containers</strong></div>` : ''}
     ${emptyContainers.length ? `<div class="tile"><span>Empty containers</span><strong>${esc(emptyContainers.length)}</strong></div>` : ''}
     <div class="tile"><span>Prepared person</span><strong>${esc(schedule.preparedByUserId)}</strong></div>
     <div class="tile"><span>Check person</span><strong>${esc(schedule.checkedByUserId)}</strong></div>
@@ -4093,6 +4164,8 @@ export class TrainSchedulingService {
         <th class="num">Equated Length</th>
         <th class="num">Tare Weight</th>
         <th class="num">Load Capacity</th>
+        <th>Departure Station</th>
+        <th>Arrival Station</th>
         <th>Cargo Type</th>
         <th>Company</th>
         <th>Container No</th>
@@ -4101,7 +4174,7 @@ export class TrainSchedulingService {
       </tr>
     </thead>
     <tbody>
-      ${rows || '<tr><td colspan="10">No wagons on this train set.</td></tr>'}
+      ${rows || '<tr><td colspan="13">No wagons on this train set.</td></tr>'}
       ${unassignedRows}
     </tbody>
   </table>
@@ -4247,30 +4320,23 @@ export class TrainSchedulingService {
         .replace(/'/g, '&#39;');
     const date = (value: unknown) => (value ? new Date(value as string | Date).toLocaleString('en-GB') : '-');
     const status = loadList.operation.status;
-    // A leg slot (boardYard set) couples mid-corridor — its cargo is NOT on the
-    // physical train this Djibouti-side document is checked against, so it must
-    // stay out of the loaded tallies or the gate count stops matching.
-    const loadsHere = (wagon: (typeof loadList.wagons)[number]) => !wagon.boardYard;
-    const totalAllocations = loadList.wagons.reduce((sum, wagon) => sum + wagon.allocations.length, 0);
-    const totalWeight = loadList.wagons.reduce(
-      (sum, wagon) =>
-        sum +
-        (loadsHere(wagon)
-          ? wagon.allocations.reduce((wagonSum, allocation) => wagonSum + Number(allocation.allocatedWeightTons || 0), 0)
-          : 0),
+    // A leg slot (boardYard set) couples mid-corridor — it is not part of the
+    // consist this Djibouti-side document is checked against yet, so it gets
+    // no row and no count here at all. Its own coupling shows up on THAT
+    // stop's own marshalling document once it actually happens.
+    const wagons = loadList.wagons.filter((wagon) => !wagon.boardYard);
+    const totalAllocations = wagons.reduce((sum, wagon) => sum + wagon.allocations.length, 0);
+    const totalWeight = wagons.reduce(
+      (sum, wagon) => sum + wagon.allocations.reduce((wagonSum, allocation) => wagonSum + Number(allocation.allocatedWeightTons || 0), 0),
       0,
     );
-    const emptyWagons = loadList.wagons.filter((wagon) => wagon.allocations.length === 0).length;
+    const emptyWagons = wagons.filter((wagon) => wagon.allocations.length === 0).length;
 
-    // Container count summary (40ft, 20ft) — loaded at origin vs. en route
-    let count40ft = 0, count20ft = 0, pendingContainers = 0;
-    loadList.wagons.forEach((wagon) => {
+    // Container count summary (40ft, 20ft)
+    let count40ft = 0, count20ft = 0;
+    wagons.forEach((wagon) => {
       wagon.allocations.forEach((allocation) => {
         (allocation.containerItems ?? []).forEach((item) => {
-          if (!loadsHere(wagon)) {
-            pendingContainers++;
-            return;
-          }
           const size = this.resolveContainerItemSize(item);
           if (size === 40) count40ft++;
           else if (size === 20) count20ft++;
@@ -4278,7 +4344,7 @@ export class TrainSchedulingService {
       });
     });
 
-    const allocationRows = loadList.wagons
+    const allocationRows = wagons
       .flatMap((wagon) => {
         const wagonCells = `<td>${esc(wagon.sequenceNo)}</td>
             <td>${esc(wagon.wagonNumber)}</td>
@@ -4311,7 +4377,7 @@ export class TrainSchedulingService {
             <td>${esc(allocation.loadType)}</td>
             <td>${esc(allocation.containerNumbers.length ? allocation.containerNumbers.join(', ') : '-')}</td>
             <td>${esc(sealNumbers || '-')}</td>
-            <td>${wagon.boardYard ? `TO BE LOADED AT ${esc(wagon.boardYard).toUpperCase()}` : ''}</td>
+            <td></td>
             <td class="num">${esc(Number(allocation.allocatedWeightTons || 0).toFixed(3))}</td>
           </tr>`;
           },
@@ -4378,13 +4444,12 @@ export class TrainSchedulingService {
       <div class="tile"><span>Origin</span><strong>${esc(loadList.origin)}</strong></div>
       <div class="tile"><span>Destination</span><strong>${esc(loadList.destination)}</strong></div>
       <div class="tile"><span>Total bookings</span><strong>${esc(loadList.totalBookings)}</strong></div>
-      <div class="tile"><span>Wagons</span><strong>${esc(loadList.wagons.length)}${emptyWagons ? ` (${emptyWagons} empty)` : ''}</strong></div>
+      <div class="tile"><span>Wagons</span><strong>${esc(wagons.length)}${emptyWagons ? ` (${emptyWagons} empty)` : ''}</strong></div>
       <div class="tile"><span>Allocations</span><strong>${esc(totalAllocations)}</strong></div>
       <div class="tile"><span>Total weight</span><strong>${esc(totalWeight.toFixed(3))} T</strong></div>
       <div class="tile"><span>Containers 40ft</span><strong>${esc(count40ft)}</strong></div>
       <div class="tile"><span>Containers 20ft</span><strong>${esc(count20ft)}</strong></div>
       <div class="tile"><span>Total containers</span><strong>${esc(count40ft + count20ft)}</strong></div>
-      ${pendingContainers ? `<div class="tile"><span>To load en route</span><strong>${esc(pendingContainers)} containers</strong></div>` : ''}
       <div class="tile"><span>Gatepass granted</span><strong>${esc(date(loadList.operation.gatepassGrantedAt))}</strong></div>
     </div>
 
diff --git a/apps/edr-freight-api/src/modules/trains/train-builder.service.ts b/apps/edr-freight-api/src/modules/trains/train-builder.service.ts
index 7b28a8582..26c29499d 100644
--- a/apps/edr-freight-api/src/modules/trains/train-builder.service.ts
+++ b/apps/edr-freight-api/src/modules/trains/train-builder.service.ts
@@ -19,6 +19,7 @@ import { combinedLocomotiveLimits } from '../train-scheduling/train-capacity.uti
 import { ScheduleWagonAdjustmentLog } from '../train-schedules/entities/schedule-wagon-adjustment-log.entity';
 import { TrainSchedule } from '../train-schedules/entities/train-schedule.entity';
 import { TrainSet } from '../train-sets/entities/train-set.entity';
+import { TrainSetLocomotive } from '../train-sets/entities/train-set-locomotive.entity';
 import { TrainSetWagon } from '../train-sets/entities/train-set-wagon.entity';
 import { WagonType } from '../wagon-types/entities/wagon-type.entity';
 import { WagonMovement } from '../wagons/entities/wagon-movement.entity';
@@ -504,7 +505,7 @@ export class TrainBuilderService {
     if (locomotiveIds.length < 1) {
       throw new BadRequestException('A train must be pulled by at least one locomotive');
     }
-    await this.dataSource.transaction(async (manager) => {
+    const pending = await this.dataSource.transaction(async (manager) => {
       const train = await this.getEditableTrain(manager, id);
       const yard = await manager
         .getRepository(Yard)
@@ -523,10 +524,76 @@ export class TrainBuilderService {
       await manager
         .getRepository(Train)
         .update(train.id, { capacityTons: round(limits?.maxPullWeightTons ?? 0) });
+      // Capacity math reads the SET's locomotives, not the train's — push the
+      // new pull weight onto the live runs too, or they keep the old ceiling.
+      return this.syncLiveSchedulesAfterLocomotiveChange(manager, train.id, locomotiveIds);
     });
+    // Re-derive FULL/reopen once committed — a bigger pull weight can free room
+    // on a schedule that had closed as FULL.
+    await this.reconcileWindowsAfterConsistChange(pending);
     return this.getComposition(id);
   }
 
+  /**
+   * Mirror a built train's locomotive change onto every LIVE (DRAFT/SCHEDULED)
+   * schedule formed from it. The three capacity axes are derived from
+   * `train_set_locomotives` (see trainSetLocomotiveLimits), which is snapshotted
+   * when the set is built and never re-synced — so adding a second locomotive
+   * raised `trains.capacity_tons` but left every existing schedule pulling on
+   * the old single-loco ceiling, still refusing bookings for want of weight.
+   *
+   * Only DRAFT/SCHEDULED runs follow the live train; DISPATCHED/ARRIVED render
+   * from their frozen snapshot and must not be disturbed (same rule as
+   * syncLiveScheduleAfterConsistChange).
+   */
+  private async syncLiveSchedulesAfterLocomotiveChange(
+    manager: EntityManager,
+    trainId: string,
+    locomotiveIds: string[],
+  ): Promise<PendingWindowCheck[]> {
+    const trainSets = await manager.getRepository(TrainSet).find({ where: { trainId } });
+    if (!trainSets.length) return [];
+
+    const schedules = await manager.getRepository(TrainSchedule).find({
+      where: {
+        trainSetId: In(trainSets.map((s) => s.id)),
+        status: In(['DRAFT', 'SCHEDULED']),
+      },
+    });
+    if (!schedules.length) return [];
+
+    // Only the sets still backing a live run — a set behind an ARRIVED schedule
+    // keeps the locomotives it actually ran with.
+    const liveSetIds = [...new Set(schedules.map((s) => s.trainSetId))];
+    const [primaryId] = locomotiveIds;
+    for (const trainSetId of liveSetIds) {
+      await manager.getRepository(TrainSetLocomotive).delete({ trainSetId });
+      await manager.getRepository(TrainSetLocomotive).save(
+        locomotiveIds.map((locomotiveId, index) =>
+          manager
+            .getRepository(TrainSetLocomotive)
+            .create({ trainSetId, locomotiveId, sequenceNo: index }),
+        ),
+      );
+      // `locomotiveId` is the primary-locomotive fallback for single-loco reads.
+      await manager.getRepository(TrainSet).update(trainSetId, { locomotiveId: primaryId });
+    }
+
+    return schedules.map((s) => ({
+      scheduleId: s.id,
+      wasFull: s.bookingWindowStatus === 'FULL',
+    }));
+  }
+
+  /** {@link reconcileWindowAfterConsistChange} over several schedules. */
+  private async reconcileWindowsAfterConsistChange(
+    pending: PendingWindowCheck[],
+  ): Promise<void> {
+    for (const check of pending) {
+      await this.reconcileWindowAfterConsistChange(check);
+    }
+  }
+
   /**
    * Edit a built train's display identity: name and fixed import/export run
    * numbers. Mirrors the build-time number rules — the pair may not collide
diff --git a/apps/edr-freight-api/src/modules/transit-agents/dto/create-transit-agent.dto.ts b/apps/edr-freight-api/src/modules/transit-agents/dto/create-transit-agent.dto.ts
index be3810c0b..d035c53f8 100644
--- a/apps/edr-freight-api/src/modules/transit-agents/dto/create-transit-agent.dto.ts
+++ b/apps/edr-freight-api/src/modules/transit-agents/dto/create-transit-agent.dto.ts
@@ -1,25 +1,34 @@
-import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
-import { Transform } from 'class-transformer';
-import { IsBoolean, IsDateString, IsOptional, IsString, MaxLength } from 'class-validator';
+import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
+import { Transform } from "class-transformer";
+import {
+  IsBoolean,
+  IsDateString,
+  IsEmail,
+  IsOptional,
+  IsString,
+  MaxLength,
+} from "class-validator";
+
+import { IsValidPhone } from "../../../common/validators/is-phone-number.validator";
 
 const toBoolean = ({ value }: { value: unknown }) => {
-  if (typeof value === 'boolean') return value;
-  if (value === 'true') return true;
-  if (value === 'false') return false;
+  if (typeof value === "boolean") return value;
+  if (value === "true") return true;
+  if (value === "false") return false;
   return value;
 };
 
 export class CreateTransitAgentDto {
-  @ApiProperty({ maxLength: 150, example: 'Ahmed Bourhan' })
+  @ApiProperty({ maxLength: 150, example: "Ahmed Bourhan" })
   @IsString()
   @MaxLength(150)
   name!: string;
 
-  @ApiProperty({ example: '2026-01-01' })
+  @ApiProperty({ example: "2026-01-01" })
   @IsDateString()
   validFrom!: string;
 
-  @ApiProperty({ example: '2026-12-31' })
+  @ApiProperty({ example: "2026-12-31" })
   @IsDateString()
   validTo!: string;
 
@@ -28,4 +37,33 @@ export class CreateTransitAgentDto {
   @Transform(toBoolean)
   @IsBoolean()
   isActive?: boolean;
+
+  /**
+   * Becomes the IAM account's email and is where the activation link is sent.
+   * Optional: an agent may be created as a GL-assignable roster entry only, and
+   * invited later. Supplying it creates the portal account right away.
+   */
+  @ApiPropertyOptional({ example: "a.bourhan@transit.dj" })
+  @IsOptional()
+  @IsEmail()
+  @MaxLength(150)
+  email?: string;
+
+  @ApiPropertyOptional({
+    example: "+25377834567",
+    description:
+      "E.164. Djiboutian (+253 77…) and Ethiopian (+251 9…) mobiles also receive the activation link by SMS.",
+  })
+  @IsOptional()
+  @IsString()
+  @MaxLength(30)
+  @IsValidPhone()
+  phoneNumber?: string;
+
+  /** Login name. Defaults to the email, which is what the agent tries first. */
+  @ApiPropertyOptional({ example: "a-bourhan" })
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  username?: string;
 }
diff --git a/apps/edr-freight-api/src/modules/transit-agents/dto/invite-transit-agent.dto.ts b/apps/edr-freight-api/src/modules/transit-agents/dto/invite-transit-agent.dto.ts
new file mode 100644
index 000000000..7b317c58c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-agents/dto/invite-transit-agent.dto.ts
@@ -0,0 +1,36 @@
+import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
+import { IsEmail, IsOptional, IsString, MaxLength } from "class-validator";
+
+import { IsValidPhone } from "../../../common/validators/is-phone-number.validator";
+
+/**
+ * Give an EXISTING roster-only transit agent a portal login.
+ *
+ * Email is required here even though it is optional on the agent itself: this
+ * endpoint's whole job is to send the activation link, and email is the only
+ * channel guaranteed to reach a Djibouti-registered officer. Omitting a field
+ * keeps whatever the agent already has.
+ */
+export class InviteTransitAgentDto {
+  @ApiProperty({ example: "a.bourhan@transit.dj" })
+  @IsEmail()
+  @MaxLength(150)
+  email!: string;
+
+  @ApiPropertyOptional({
+    example: "+25377834567",
+    description:
+      "E.164. Djiboutian (+253 77…) and Ethiopian (+251 9…) mobiles also receive the activation link by SMS.",
+  })
+  @IsOptional()
+  @IsString()
+  @MaxLength(30)
+  @IsValidPhone()
+  phoneNumber?: string;
+
+  @ApiPropertyOptional({ example: "a-bourhan" })
+  @IsOptional()
+  @IsString()
+  @MaxLength(100)
+  username?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/transit-agents/dto/update-transit-agent.dto.ts b/apps/edr-freight-api/src/modules/transit-agents/dto/update-transit-agent.dto.ts
index 7e18a93da..08f28473c 100644
--- a/apps/edr-freight-api/src/modules/transit-agents/dto/update-transit-agent.dto.ts
+++ b/apps/edr-freight-api/src/modules/transit-agents/dto/update-transit-agent.dto.ts
@@ -1,5 +1,5 @@
-import { PartialType } from '@nestjs/mapped-types';
+import { PartialType } from "@nestjs/mapped-types";
 
-import { CreateTransitAgentDto } from './create-transit-agent.dto';
+import { CreateTransitAgentDto } from "./create-transit-agent.dto";
 
 export class UpdateTransitAgentDto extends PartialType(CreateTransitAgentDto) {}
diff --git a/apps/edr-freight-api/src/modules/transit-agents/entities/transit-agent.entity.ts b/apps/edr-freight-api/src/modules/transit-agents/entities/transit-agent.entity.ts
index 6d0ef9158..433b6587f 100644
--- a/apps/edr-freight-api/src/modules/transit-agents/entities/transit-agent.entity.ts
+++ b/apps/edr-freight-api/src/modules/transit-agents/entities/transit-agent.entity.ts
@@ -1,5 +1,5 @@
-import { BaseEntity } from '@edr/api-common';
-import { Column, Entity, Index } from 'typeorm';
+import { BaseEntity } from "@edr/api-common";
+import { Column, Entity, Index } from "typeorm";
 
 /**
  * Djibouti transit officer GL Djibouti may assign against a shipment's
@@ -7,18 +7,43 @@ import { Column, Entity, Index } from 'typeorm';
  * validity window arrive without a code change; `isActive` is the manual
  * suspend/reactivate switch, independent of the validity window.
  */
-@Entity({ schema: 'freight', name: 'transit_agents' })
-@Index(['isActive'])
+@Entity({ schema: "freight", name: "transit_agents" })
+@Index(["isActive"])
 export class TransitAgent extends BaseEntity {
-  @Column({ name: 'name', type: 'varchar', length: 150 })
+  @Column({ name: "name", type: "varchar", length: 150 })
   name!: string;
 
-  @Column({ name: 'valid_from', type: 'date' })
+  @Column({ name: "valid_from", type: "date" })
   validFrom!: string;
 
-  @Column({ name: 'valid_to', type: 'date' })
+  @Column({ name: "valid_to", type: "date" })
   validTo!: string;
 
-  @Column({ name: 'is_active', type: 'boolean', default: true })
+  @Column({ name: "is_active", type: "boolean", default: true })
   isActive!: boolean;
+
+  /**
+   * The IAM account (`iam.users`, userType `individual`) that signs in to the
+   * portal as this agent. No FK: `iam` is a separate schema owned by the IAM
+   * service, and the rest of the codebase reaches it by query rather than by
+   * relation.
+   *
+   * NULL for every agent that exists only as a GL-assignable roster entry —
+   * which is all of them before this feature, and stays legal afterwards. An
+   * agent gains an account when staff invite it, so `userId !== null` IS the
+   * "has a portal login" predicate; nothing else needs to track it.
+   */
+  @Column({ name: "user_id", type: "uuid", nullable: true })
+  userId?: string | null;
+
+  /**
+   * Mirrors the IAM account's email; the activation link is sent here. Nullable
+   * because a roster-only agent has never needed one — but an invite cannot be
+   * sent without it, so {@link TransitAgentsService.invite} requires it.
+   */
+  @Column({ name: "email", type: "varchar", length: 150, nullable: true })
+  email?: string | null;
+
+  @Column({ name: "phone_number", type: "varchar", length: 30, nullable: true })
+  phoneNumber?: string | null;
 }
diff --git a/apps/edr-freight-api/src/modules/transit-agents/transit-agents.controller.ts b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.controller.ts
index 4f4b90c7b..d254f7982 100644
--- a/apps/edr-freight-api/src/modules/transit-agents/transit-agents.controller.ts
+++ b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.controller.ts
@@ -10,36 +10,38 @@ import {
   Patch,
   Post,
   Query,
-} from '@nestjs/common';
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger';
+} from "@nestjs/common";
+import { ApiBearerAuth, ApiOperation, ApiTags } from "@nestjs/swagger";
 
 import {
   RuleEngineCreate,
   RuleEngineDelete,
   RuleEngineUpdate,
   RuleEngineView,
-} from '../../common/rule-engine-guards';
+} from "../../common/rule-engine-guards";
 
-import { CreateTransitAgentDto } from './dto/create-transit-agent.dto';
-import { UpdateTransitAgentDto } from './dto/update-transit-agent.dto';
-import { TransitAgentsService } from './transit-agents.service';
+import { BackofficeResetPasswordDto } from "../auth/dto/forgot-password.dto";
+import { CreateTransitAgentDto } from "./dto/create-transit-agent.dto";
+import { InviteTransitAgentDto } from "./dto/invite-transit-agent.dto";
+import { UpdateTransitAgentDto } from "./dto/update-transit-agent.dto";
+import { TransitAgentsService } from "./transit-agents.service";
 
-@ApiTags('transit-agents')
-@Controller('transit-agents')
+@ApiTags("transit-agents")
+@Controller("transit-agents")
 @ApiBearerAuth()
 export class TransitAgentsController {
   constructor(private readonly transitAgentsService: TransitAgentsService) {}
 
   @Get()
-  @RuleEngineView('transit-agents')
-  @ApiOperation({ summary: 'List transit agents' })
+  @RuleEngineView("transit-agents")
+  @ApiOperation({ summary: "List transit agents" })
   findAll(@Query() query: Record<string, string | undefined>) {
     return this.transitAgentsService.findAll({
       isActive:
-        query.isActive === 'all'
+        query.isActive === "all"
           ? undefined
           : query.isActive !== undefined
-            ? query.isActive === 'true'
+            ? query.isActive === "true"
             : undefined,
       page: query.page ? parseInt(query.page, 10) : undefined,
       pageSize: query.pageSize ? parseInt(query.pageSize, 10) : undefined,
@@ -49,39 +51,77 @@ export class TransitAgentsController {
   }
 
   /** Active + currently valid officers — the transit-assignee assignment dropdown. */
-  @Get('assignable')
-  @RuleEngineView('transit-agents')
-  @ApiOperation({ summary: 'List transit agents assignable right now (active and in-window)' })
+  @Get("assignable")
+  @RuleEngineView("transit-agents")
+  @ApiOperation({
+    summary: "List transit agents assignable right now (active and in-window)",
+  })
   findAssignable() {
     return this.transitAgentsService.findAssignable();
   }
 
-  @Get(':id')
-  @RuleEngineView('transit-agents')
-  @ApiOperation({ summary: 'Get a transit agent by ID' })
-  findOne(@Param('id', ParseUUIDPipe) id: string) {
+  @Get(":id")
+  @RuleEngineView("transit-agents")
+  @ApiOperation({ summary: "Get a transit agent by ID" })
+  findOne(@Param("id", ParseUUIDPipe) id: string) {
     return this.transitAgentsService.findById(id);
   }
 
   @Post()
-  @RuleEngineCreate('transit-agents')
-  @ApiOperation({ summary: 'Create a transit agent' })
+  @RuleEngineCreate("transit-agents")
+  @ApiOperation({
+    summary:
+      "Create a transit agent; with an email, also creates its portal account and sends the activation link",
+  })
   create(@Body() dto: CreateTransitAgentDto) {
-    return this.transitAgentsService.create(dto);
+    return this.transitAgentsService.createWithInvite(dto);
   }
 
-  @Patch(':id')
-  @RuleEngineUpdate('transit-agents')
-  @ApiOperation({ summary: 'Update a transit agent' })
-  update(@Param('id', ParseUUIDPipe) id: string, @Body() dto: UpdateTransitAgentDto) {
+  /**
+   * The path for the roster entries already in production: they were created
+   * before transit agents had logins, so they get their account here rather
+   * than at create time.
+   */
+  @Post(":id/invite")
+  @RuleEngineUpdate("transit-agents")
+  @ApiOperation({
+    summary:
+      "Create a portal account for an existing transit agent and send the activation link",
+  })
+  invite(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: InviteTransitAgentDto,
+  ) {
+    return this.transitAgentsService.invite(id, dto);
+  }
+
+  @Post(":id/resend-activation")
+  @RuleEngineUpdate("transit-agents")
+  @ApiOperation({
+    summary: "Resend a transit agent's activation / password-reset link",
+  })
+  resendActivation(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: BackofficeResetPasswordDto,
+  ) {
+    return this.transitAgentsService.resendActivation(id, dto.channel);
+  }
+
+  @Patch(":id")
+  @RuleEngineUpdate("transit-agents")
+  @ApiOperation({ summary: "Update a transit agent" })
+  update(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: UpdateTransitAgentDto,
+  ) {
     return this.transitAgentsService.update(id, dto);
   }
 
-  @Delete(':id')
-  @RuleEngineDelete('transit-agents')
+  @Delete(":id")
+  @RuleEngineDelete("transit-agents")
   @HttpCode(HttpStatus.NO_CONTENT)
-  @ApiOperation({ summary: 'Soft-delete a transit agent' })
-  remove(@Param('id', ParseUUIDPipe) id: string) {
+  @ApiOperation({ summary: "Soft-delete a transit agent" })
+  remove(@Param("id", ParseUUIDPipe) id: string) {
     return this.transitAgentsService.remove(id);
   }
 }
diff --git a/apps/edr-freight-api/src/modules/transit-agents/transit-agents.module.ts b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.module.ts
index 47e655e94..425971170 100644
--- a/apps/edr-freight-api/src/modules/transit-agents/transit-agents.module.ts
+++ b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.module.ts
@@ -1,13 +1,24 @@
-import { Module } from '@nestjs/common';
-import { TypeOrmModule } from '@nestjs/typeorm';
+import { Module } from "@nestjs/common";
+import { TypeOrmModule } from "@nestjs/typeorm";
 
-import { TransitAgent } from './entities/transit-agent.entity';
-import { TransitAgentsController } from './transit-agents.controller';
-import { TransitAgentsRepository } from './transit-agents.repository';
-import { TransitAgentsService } from './transit-agents.service';
+import { User } from "@tria-plc/iamapi-common/entities/iam/user/user.entity";
+
+import { FreightAuthModule } from "../auth/freight-auth.module";
+import { OtpModule } from "../otp/otp.module";
+import { TransitAgent } from "./entities/transit-agent.entity";
+import { TransitAgentsController } from "./transit-agents.controller";
+import { TransitAgentsRepository } from "./transit-agents.repository";
+import { TransitAgentsService } from "./transit-agents.service";
 
 @Module({
-  imports: [TypeOrmModule.forFeature([TransitAgent])],
+  imports: [
+    // `User` is registered here so this module can create the IAM account that
+    // backs an invited transit agent, in the same transaction as the agent row.
+    TypeOrmModule.forFeature([TransitAgent, User]),
+    // CustomerResetService — activation links reuse the staff-triggered reset path.
+    FreightAuthModule,
+    OtpModule,
+  ],
   controllers: [TransitAgentsController],
   providers: [TransitAgentsRepository, TransitAgentsService],
   exports: [TransitAgentsRepository, TransitAgentsService],
diff --git a/apps/edr-freight-api/src/modules/transit-agents/transit-agents.repository.ts b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.repository.ts
index 4418ad938..5ae4191eb 100644
--- a/apps/edr-freight-api/src/modules/transit-agents/transit-agents.repository.ts
+++ b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.repository.ts
@@ -1,9 +1,14 @@
-import { BaseRepository } from '@edr/api-common';
-import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { LessThanOrEqual, MoreThanOrEqual, Repository } from 'typeorm';
+import { BaseRepository } from "@edr/api-common";
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import {
+  EntityManager,
+  LessThanOrEqual,
+  MoreThanOrEqual,
+  Repository,
+} from "typeorm";
 
-import { TransitAgent } from './entities/transit-agent.entity';
+import { TransitAgent } from "./entities/transit-agent.entity";
 
 @Injectable()
 export class TransitAgentsRepository extends BaseRepository<TransitAgent> {
@@ -22,7 +27,48 @@ export class TransitAgentsRepository extends BaseRepository<TransitAgent> {
         validFrom: LessThanOrEqual(today),
         validTo: MoreThanOrEqual(today),
       },
-      order: { name: 'ASC' },
+      order: { name: "ASC" },
     });
   }
+
+  /** The transit agent signed in as `userId`, or null for any other account. */
+  findByUserId(userId: string): Promise<TransitAgent | null> {
+    return this.repository.findOne({ where: { userId } });
+  }
+
+  /**
+   * Case-insensitive, matching the `lower(email)` unique index. `exceptId` lets
+   * an update re-save its own address without colliding with itself.
+   */
+  async existsByEmail(email: string, exceptId?: string): Promise<boolean> {
+    const qb = this.repository
+      .createQueryBuilder("ta")
+      .where("lower(ta.email) = lower(:email)", { email });
+    if (exceptId) qb.andWhere("ta.id != :exceptId", { exceptId });
+    return (await qb.getCount()) > 0;
+  }
+
+  /**
+   * Insert inside a caller-supplied transaction, so the agent row and the IAM
+   * user it points at commit together — a row referencing a user that was
+   * rolled back (or vice versa) is an account nobody can sign in to.
+   */
+  createInTransaction(
+    manager: EntityManager,
+    data: Partial<TransitAgent>,
+  ): Promise<TransitAgent> {
+    const repo = manager.getRepository(TransitAgent);
+    return repo.save(repo.create(data));
+  }
+
+  /** Attach an IAM account to an existing agent, inside the caller's transaction. */
+  async linkAccountInTransaction(
+    manager: EntityManager,
+    id: string,
+    data: Pick<TransitAgent, "userId" | "email" | "phoneNumber">,
+  ): Promise<TransitAgent> {
+    const repo = manager.getRepository(TransitAgent);
+    await repo.update(id, data);
+    return repo.findOneOrFail({ where: { id } });
+  }
 }
diff --git a/apps/edr-freight-api/src/modules/transit-agents/transit-agents.service.spec.ts b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.service.spec.ts
new file mode 100644
index 000000000..3aa5e6e02
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.service.spec.ts
@@ -0,0 +1,346 @@
+import { BadRequestException, ConflictException } from "@nestjs/common";
+import {
+  EUserStatus,
+  EUserType,
+} from "@tria-plc/api-common/utils/enums/user.enum";
+
+import { ResetChannel } from "../auth/dto/forgot-password.dto";
+import { TransitAgentsService } from "./transit-agents.service";
+
+/**
+ * The account half of a transit agent. The roster half (validity window,
+ * assignability) predates this and is untouched — what these lock is that
+ * adding a login did not make an account MANDATORY, since production is full of
+ * roster-only agents that must keep working.
+ */
+describe("TransitAgentsService accounts", () => {
+  const savedUser = { id: "user-1" };
+
+  let repo: {
+    existsByEmail: jest.Mock;
+    createInTransaction: jest.Mock;
+    linkAccountInTransaction: jest.Mock;
+    findById: jest.Mock;
+    findByUserId: jest.Mock;
+    create: jest.Mock;
+    update: jest.Mock;
+  };
+  let userRepository: { findOne: jest.Mock; update: jest.Mock };
+  let customerResetService: {
+    sendResetLinkToUser: jest.Mock;
+    sendResetLinkToUserOnChannels: jest.Mock;
+  };
+  let dataSource: { transaction: jest.Mock };
+  let userRepoInTx: { create: jest.Mock; save: jest.Mock };
+  let service: TransitAgentsService;
+
+  const base = {
+    name: "Ahmed Bourhan",
+    validFrom: "2026-01-01",
+    validTo: "2026-12-31",
+  };
+
+  beforeEach(() => {
+    userRepoInTx = {
+      create: jest.fn((v) => v),
+      save: jest.fn().mockResolvedValue(savedUser),
+    };
+
+    repo = {
+      existsByEmail: jest.fn().mockResolvedValue(false),
+      createInTransaction: jest.fn(async (_m, data) => ({
+        id: "ta-1",
+        ...data,
+      })),
+      linkAccountInTransaction: jest.fn(async (_m, id, data) => ({
+        id,
+        ...base,
+        isActive: true,
+        ...data,
+      })),
+      findById: jest.fn(),
+      findByUserId: jest.fn(),
+      create: jest.fn(async (data) => ({ id: "ta-1", ...data })),
+      // `BaseRepository.update` re-reads the row via `findById`, so the result
+      // carries columns the caller never passed — `userId` above all, which is
+      // what decides whether IAM gets synced.
+      update: jest.fn(async (id, data) => ({
+        ...(await repo.findById(id)),
+        id,
+        ...data,
+      })),
+    };
+    userRepository = {
+      findOne: jest.fn().mockResolvedValue(null),
+      update: jest.fn(),
+    };
+    customerResetService = {
+      sendResetLinkToUser: jest
+        .fn()
+        .mockResolvedValue({
+          maskedTarget: "a**@transit.dj",
+          channel: ResetChannel.Email,
+        }),
+      sendResetLinkToUserOnChannels: jest
+        .fn()
+        .mockResolvedValue([
+          { maskedTarget: "a**@transit.dj", channel: ResetChannel.Email },
+        ]),
+    };
+    dataSource = {
+      transaction: jest.fn(async (cb) =>
+        cb({ getRepository: () => userRepoInTx } as never),
+      ),
+    };
+
+    service = new TransitAgentsService(
+      repo as never,
+      userRepository as never,
+      customerResetService as never,
+      dataSource as never,
+    );
+  });
+
+  describe("create", () => {
+    it("creates a roster-only agent with no account when no email is given", async () => {
+      const { agent, activationSentTo } = await service.createWithInvite(base);
+
+      expect(dataSource.transaction).not.toHaveBeenCalled();
+      expect(
+        customerResetService.sendResetLinkToUserOnChannels,
+      ).not.toHaveBeenCalled();
+      expect(agent.hasAccount).toBe(false);
+      expect(activationSentTo).toBeNull();
+    });
+
+    it("creates the IAM account with no password set when an email is given", async () => {
+      await service.createWithInvite({
+        ...base,
+        email: "A.Bourhan@Transit.DJ",
+      });
+
+      expect(userRepoInTx.save).toHaveBeenCalledWith(
+        expect.objectContaining({
+          email: "a.bourhan@transit.dj",
+          username: "a.bourhan@transit.dj",
+          userType: EUserType.INDIVIDUAL,
+          hasSetPassword: false,
+          status: EUserStatus.ACCEPTED,
+        }),
+      );
+    });
+
+    it("sends the activation link only after the transaction commits", async () => {
+      const order: string[] = [];
+      dataSource.transaction.mockImplementation(
+        async (cb: (m: unknown) => unknown) => {
+          const result = await cb({ getRepository: () => userRepoInTx });
+          order.push("commit");
+          return result;
+        },
+      );
+      customerResetService.sendResetLinkToUserOnChannels.mockImplementation(
+        async () => {
+          order.push("send");
+          return [
+            { maskedTarget: "a**@transit.dj", channel: ResetChannel.Email },
+          ];
+        },
+      );
+
+      await service.createWithInvite({ ...base, email: "a@transit.dj" });
+
+      expect(order).toEqual(["commit", "send"]);
+    });
+  });
+
+  describe("invite", () => {
+    it("attaches an account to an existing roster-only agent and sends the link", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: null,
+      });
+
+      const { agent, activationSentTo } = await service.invite("ta-1", {
+        email: "a@transit.dj",
+      });
+
+      expect(repo.linkAccountInTransaction).toHaveBeenCalledWith(
+        expect.anything(),
+        "ta-1",
+        expect.objectContaining({ userId: "user-1", email: "a@transit.dj" }),
+      );
+      expect(agent.hasAccount).toBe(true);
+      expect(activationSentTo).toBe("a**@transit.dj");
+    });
+
+    it("refuses to mint a second account for an agent that already has one", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: "user-9",
+      });
+
+      await expect(
+        service.invite("ta-1", { email: "a@transit.dj" }),
+      ).rejects.toThrow(ConflictException);
+      expect(dataSource.transaction).not.toHaveBeenCalled();
+    });
+
+    it("refuses credentials that already belong to another account", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: null,
+      });
+      userRepository.findOne.mockResolvedValue({ id: "someone-else" });
+
+      await expect(
+        service.invite("ta-1", { email: "a@transit.dj" }),
+      ).rejects.toThrow(ConflictException);
+    });
+
+    it("texts the link as well when the number is domestic", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: null,
+      });
+
+      await service.invite("ta-1", {
+        email: "a@transit.dj",
+        phoneNumber: "+251911223344",
+      });
+
+      expect(
+        customerResetService.sendResetLinkToUserOnChannels,
+      ).toHaveBeenCalledWith(
+        "user-1",
+        [ResetChannel.Email, ResetChannel.Phone],
+        expect.objectContaining({ allowWithoutCredential: true }),
+      );
+    });
+
+    it("emails only when the number is foreign — the SMS gateway is domestic-only", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: null,
+      });
+
+      await service.invite("ta-1", {
+        email: "a@transit.dj",
+        phoneNumber: "+33612345678",
+      });
+
+      expect(
+        customerResetService.sendResetLinkToUserOnChannels,
+      ).toHaveBeenCalledWith("user-1", [ResetChannel.Email], expect.anything());
+    });
+  });
+
+  describe("update", () => {
+    it("mirrors an edited email onto the linked IAM account", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: "user-1",
+      });
+
+      await service.update("ta-1", { email: "New@Transit.DJ" });
+
+      expect(repo.update).toHaveBeenCalledWith(
+        "ta-1",
+        expect.objectContaining({ email: "new@transit.dj" }),
+      );
+      expect(userRepository.update).toHaveBeenCalledWith(
+        "user-1",
+        expect.objectContaining({ email: "new@transit.dj" }),
+      );
+    });
+
+    it("never writes username — it names an IAM account, not a column on this table", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: null,
+      });
+
+      await service.update("ta-1", { username: "nope" } as never);
+
+      expect(repo.update).toHaveBeenCalledWith(
+        "ta-1",
+        expect.not.objectContaining({ username: expect.anything() }),
+      );
+    });
+
+    it("leaves IAM alone for a roster-only agent", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: null,
+      });
+
+      await service.update("ta-1", { email: "a@transit.dj" });
+
+      expect(userRepository.update).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("resendActivation", () => {
+    it("refuses for an agent that has no account yet", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: null,
+      });
+
+      await expect(
+        service.resendActivation("ta-1", ResetChannel.Email),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it("refuses an SMS resend to a foreign number", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: "user-1",
+        phoneNumber: "+33612345678",
+      });
+
+      await expect(
+        service.resendActivation("ta-1", ResetChannel.Phone),
+      ).rejects.toThrow(BadRequestException);
+    });
+
+    it("reuses the existing account rather than minting a new one", async () => {
+      repo.findById.mockResolvedValue({
+        id: "ta-1",
+        ...base,
+        isActive: true,
+        userId: "user-1",
+        email: "a@transit.dj",
+      });
+
+      await service.resendActivation("ta-1", ResetChannel.Email);
+
+      expect(customerResetService.sendResetLinkToUser).toHaveBeenCalledWith(
+        "user-1",
+        ResetChannel.Email,
+        expect.objectContaining({ allowWithoutCredential: true }),
+      );
+      expect(dataSource.transaction).not.toHaveBeenCalled();
+    });
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/transit-agents/transit-agents.service.ts b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.service.ts
index ec9c24e9d..b54f1fddb 100644
--- a/apps/edr-freight-api/src/modules/transit-agents/transit-agents.service.ts
+++ b/apps/edr-freight-api/src/modules/transit-agents/transit-agents.service.ts
@@ -1,17 +1,49 @@
-import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
-import { FindOptionsOrder } from 'typeorm';
+import {
+  BadRequestException,
+  ConflictException,
+  Injectable,
+  Logger,
+  NotFoundException,
+} from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import {
+  EUserStatus,
+  EUserType,
+} from "@tria-plc/api-common/utils/enums/user.enum";
+// Subpath import (not the package root) so ts-jest can resolve it when this
+// file lands in a spec's compile graph — same reason as backoffice.service.ts.
+import { User } from "@tria-plc/iamapi-common/entities/iam/user/user.entity";
+import {
+  DataSource,
+  EntityManager,
+  FindOptionsOrder,
+  Repository,
+} from "typeorm";
 
-import { CreateTransitAgentDto } from './dto/create-transit-agent.dto';
-import { UpdateTransitAgentDto } from './dto/update-transit-agent.dto';
-import { TransitAgent } from './entities/transit-agent.entity';
-import { TransitAgentsRepository } from './transit-agents.repository';
+import { CustomerResetService } from "../auth/customer-reset.service";
+import { ResetChannel } from "../auth/dto/forgot-password.dto";
+import { isDomesticPhone } from "../otp/otp.service";
+import { CreateTransitAgentDto } from "./dto/create-transit-agent.dto";
+import { InviteTransitAgentDto } from "./dto/invite-transit-agent.dto";
+import { UpdateTransitAgentDto } from "./dto/update-transit-agent.dto";
+import { TransitAgent } from "./entities/transit-agent.entity";
+import { TransitAgentsRepository } from "./transit-agents.repository";
 
-export type TransitAgentValidityStatus = 'VALID' | 'NOT_STARTED' | 'EXPIRED';
+export type TransitAgentValidityStatus = "VALID" | "NOT_STARTED" | "EXPIRED";
 
 export type TransitAgentView = TransitAgent & {
   validityStatus: TransitAgentValidityStatus;
+  /** True once an IAM account backs this agent — i.e. it can sign in. */
+  hasAccount: boolean;
 };
 
+export interface InvitedTransitAgent {
+  agent: TransitAgentView;
+  /** Masked destination of the activation link, or null if none was sent. */
+  activationSentTo: string | null;
+  activationChannel: ResetChannel | null;
+}
+
 type TransitAgentListFilter = {
   isActive?: boolean;
   page?: number;
@@ -25,20 +57,34 @@ function todayISODate(): string {
   return new Date().toISOString().slice(0, 10);
 }
 
-function validityStatus(agent: Pick<TransitAgent, 'validFrom' | 'validTo'>): TransitAgentValidityStatus {
+function validityStatus(
+  agent: Pick<TransitAgent, "validFrom" | "validTo">,
+): TransitAgentValidityStatus {
   const today = todayISODate();
-  if (today < agent.validFrom) return 'NOT_STARTED';
-  if (today > agent.validTo) return 'EXPIRED';
-  return 'VALID';
+  if (today < agent.validFrom) return "NOT_STARTED";
+  if (today > agent.validTo) return "EXPIRED";
+  return "VALID";
 }
 
 function withValidityStatus(agent: TransitAgent): TransitAgentView {
-  return { ...agent, validityStatus: validityStatus(agent) };
+  return {
+    ...agent,
+    validityStatus: validityStatus(agent),
+    hasAccount: Boolean(agent.userId),
+  };
 }
 
 @Injectable()
 export class TransitAgentsService {
-  constructor(private readonly transitAgentsRepository: TransitAgentsRepository) {}
+  private readonly logger = new Logger(TransitAgentsService.name);
+
+  constructor(
+    private readonly transitAgentsRepository: TransitAgentsRepository,
+    @InjectRepository(User)
+    private readonly userRepository: Repository<User>,
+    private readonly customerResetService: CustomerResetService,
+    private readonly dataSource: DataSource,
+  ) {}
 
   async findAll(filter: TransitAgentListFilter = {}): Promise<{
     data: TransitAgentView[];
@@ -46,10 +92,13 @@ export class TransitAgentsService {
   }> {
     const page = filter.page ?? 1;
     const pageSize = filter.pageSize ?? 500;
-    const sortBy = ['name', 'validFrom', 'validTo', 'isActive'].includes(filter.sortBy ?? '')
+    const sortBy = ["name", "validFrom", "validTo", "isActive"].includes(
+      filter.sortBy ?? "",
+    )
       ? (filter.sortBy as keyof TransitAgent)
-      : 'name';
-    const sortOrder = filter.sortOrder?.toUpperCase() === 'DESC' ? 'DESC' : 'ASC';
+      : "name";
+    const sortOrder =
+      filter.sortOrder?.toUpperCase() === "DESC" ? "DESC" : "ASC";
 
     const [data, total] = await this.transitAgentsRepository.findAndCount({
       where: filter.isActive === undefined ? {} : { isActive: filter.isActive },
@@ -86,12 +135,14 @@ export class TransitAgentsService {
   async getAssignable(id: string): Promise<TransitAgent> {
     const agent = await this.transitAgentsRepository.findById(id);
     if (!agent) {
-      throw new BadRequestException('Selected transit officer was not found.');
+      throw new BadRequestException("Selected transit officer was not found.");
     }
     if (!agent.isActive) {
-      throw new BadRequestException(`${agent.name} is suspended — pick another transit officer.`);
+      throw new BadRequestException(
+        `${agent.name} is suspended — pick another transit officer.`,
+      );
     }
-    if (validityStatus(agent) !== 'VALID') {
+    if (validityStatus(agent) !== "VALID") {
       throw new BadRequestException(
         `${agent.name}'s validity window has expired — pick another transit officer or extend their dates.`,
       );
@@ -99,38 +150,364 @@ export class TransitAgentsService {
     return agent;
   }
 
-  async create(dto: CreateTransitAgentDto): Promise<TransitAgentView> {
-    if (dto.validTo < dto.validFrom) {
-      throw new BadRequestException('Valid-to date must be on or after valid-from date.');
+  /**
+   * Create an IAM account for a transit agent, inside the caller's transaction.
+   *
+   * Follows `ShippingLineCompaniesService.register` — same entities, same shape
+   * — including its one deliberate difference from employee creation: no
+   * `UserCredential` row is written and `hasSetPassword` stays false, so the
+   * agent must come through the activation link. Staff never handle a password.
+   */
+  private async createIamAccount(
+    manager: EntityManager,
+    args: {
+      name: string;
+      email: string;
+      username: string;
+      phoneNumber?: string;
+    },
+  ): Promise<string> {
+    const userRepo = manager.getRepository(User);
+    const user = await userRepo.save(
+      userRepo.create({
+        email: args.email,
+        username: args.username,
+        phoneNumber: args.phoneNumber,
+        name: { en: args.name },
+        userType: EUserType.INDIVIDUAL,
+        isActive: true,
+        // No credential row: the account has no password until the activation
+        // link is used. `hasSetPassword` must stay false or the portal treats
+        // the account as ready to sign in with a password that does not exist.
+        hasSetPassword: false,
+        status: EUserStatus.ACCEPTED,
+      }),
+    );
+    return user.id as string;
+  }
+
+  /**
+   * Normalize and validate the account fields shared by create and invite, and
+   * refuse credentials that already belong to somebody.
+   */
+  private async prepareAccountFields(
+    dto: { email: string; phoneNumber?: string; username?: string },
+    exceptAgentId?: string,
+  ) {
+    const email = dto.email.trim().toLowerCase();
+    const username = (dto.username?.trim() || email).toLowerCase();
+    const phoneNumber = dto.phoneNumber?.trim() || undefined;
+
+    if (
+      await this.transitAgentsRepository.existsByEmail(email, exceptAgentId)
+    ) {
+      throw new ConflictException(
+        `A transit agent with email ${email} already exists`,
+      );
     }
-    const agent = await this.transitAgentsRepository.create({
+
+    // An existing IAM account means these credentials already belong to a
+    // customer, a shipping line or an employee. Reusing it would let one login
+    // resolve to two different account kinds, so this is refused rather than
+    // merged.
+    const existingUser = await this.userRepository.findOne({
+      where: [{ email }, { username }],
+      select: { id: true },
+    });
+    if (existingUser) {
+      throw new ConflictException("email_or_username_already_in_use");
+    }
+
+    return { email, username, phoneNumber };
+  }
+
+  /**
+   * Create a transit agent.
+   *
+   * With no `email` this is the pre-existing behaviour: a GL-assignable roster
+   * entry with no login, which is what production is full of. With an `email`
+   * the IAM account and the agent row are created in one transaction and the
+   * activation link goes out.
+   */
+  async create(dto: CreateTransitAgentDto): Promise<TransitAgentView> {
+    return (await this.createWithInvite(dto)).agent;
+  }
+
+  /** {@link create}, also reporting where the activation link went. */
+  async createWithInvite(
+    dto: CreateTransitAgentDto,
+  ): Promise<InvitedTransitAgent> {
+    if (dto.validTo < dto.validFrom) {
+      throw new BadRequestException(
+        "Valid-to date must be on or after valid-from date.",
+      );
+    }
+
+    const base = {
       name: dto.name.trim(),
       validFrom: dto.validFrom,
       validTo: dto.validTo,
       isActive: dto.isActive ?? true,
+    };
+
+    if (!dto.email) {
+      // Roster-only agent — no account, nothing to send.
+      const agent = await this.transitAgentsRepository.create(base);
+      return {
+        agent: withValidityStatus(agent),
+        activationSentTo: null,
+        activationChannel: null,
+      };
+    }
+
+    const { email, username, phoneNumber } = await this.prepareAccountFields({
+      email: dto.email,
+      phoneNumber: dto.phoneNumber,
+      username: dto.username,
     });
-    return withValidityStatus(agent);
+
+    const agent = await this.dataSource.transaction(async (manager) => {
+      const userId = await this.createIamAccount(manager, {
+        name: base.name,
+        email,
+        username,
+        phoneNumber,
+      });
+      return this.transitAgentsRepository.createInTransaction(manager, {
+        ...base,
+        userId,
+        email,
+        phoneNumber: phoneNumber ?? null,
+      });
+    });
+
+    // Outside the transaction on purpose: a delivery failure must not roll back
+    // a registered agent. The link is resendable, and the account is already
+    // valid without it.
+    const activation = await this.sendActivationLink(agent);
+    return {
+      agent: withValidityStatus(agent),
+      activationSentTo: activation?.maskedTarget ?? null,
+      activationChannel: activation?.channel ?? null,
+    };
   }
 
-  async update(id: string, dto: UpdateTransitAgentDto): Promise<TransitAgentView> {
+  /**
+   * Give an EXISTING agent a portal login — the path for the roster entries
+   * already in production. Creates the IAM account, attaches it, and sends the
+   * activation link.
+   */
+  async invite(
+    id: string,
+    dto: InviteTransitAgentDto,
+  ): Promise<InvitedTransitAgent> {
+    const current = await this.transitAgentsRepository.findById(id);
+    if (!current) {
+      throw new NotFoundException(`Transit agent ${id} not found`);
+    }
+    if (current.userId) {
+      // Already has an account — resending is `resendActivation`, which reuses
+      // the existing user instead of minting a second one for the same person.
+      throw new ConflictException(
+        "This transit agent already has a portal account — resend the activation link instead.",
+      );
+    }
+
+    const { email, username, phoneNumber } = await this.prepareAccountFields(
+      dto,
+      id,
+    );
+
+    const agent = await this.dataSource.transaction(async (manager) => {
+      const userId = await this.createIamAccount(manager, {
+        name: current.name,
+        email,
+        username,
+        phoneNumber,
+      });
+      return this.transitAgentsRepository.linkAccountInTransaction(
+        manager,
+        id,
+        {
+          userId,
+          email,
+          phoneNumber: phoneNumber ?? null,
+        },
+      );
+    });
+
+    const activation = await this.sendActivationLink(agent);
+    return {
+      agent: withValidityStatus(agent),
+      activationSentTo: activation?.maskedTarget ?? null,
+      activationChannel: activation?.channel ?? null,
+    };
+  }
+
+  /**
+   * Send the activation link.
+   *
+   * Email always goes out — it is the only channel guaranteed to reach a
+   * foreign-registered officer. SMS is sent in addition when the number is
+   * domestic, since the gateway silently drops anything else. Both carry the
+   * SAME single-use ticket: minting retires earlier tickets, so two mints would
+   * kill the email link the moment the SMS went out.
+   *
+   * Reports the email send, as that is the one that is always attempted.
+   */
+  async sendActivationLink(agent: TransitAgent) {
+    if (!agent.userId) return null;
+
+    const scope = `transit agent ${agent.id}`;
+    const channels = [ResetChannel.Email];
+    if (agent.phoneNumber && isDomesticPhone(agent.phoneNumber)) {
+      channels.push(ResetChannel.Phone);
+    }
+
+    const sent = await this.customerResetService.sendResetLinkToUserOnChannels(
+      agent.userId,
+      channels,
+      { scope, allowWithoutCredential: true },
+    );
+    const emailed = sent.find((s) => s.channel === ResetChannel.Email) ?? null;
+
+    if (!emailed) {
+      this.logger.error(
+        `Activation email not sent for transit agent ${agent.id} — no reachable address`,
+      );
+    }
+    if (
+      channels.includes(ResetChannel.Phone) &&
+      !sent.some((s) => s.channel === ResetChannel.Phone)
+    ) {
+      this.logger.warn(`Activation SMS not sent for transit agent ${agent.id}`);
+    }
+
+    return emailed;
+  }
+
+  async resendActivation(id: string, channel: ResetChannel) {
+    const agent = await this.transitAgentsRepository.findById(id);
+    if (!agent) {
+      throw new NotFoundException("Transit agent not found");
+    }
+    if (!agent.userId) {
+      throw new BadRequestException(
+        "This transit agent has no portal account yet — invite them first.",
+      );
+    }
+
+    if (
+      channel === ResetChannel.Phone &&
+      (!agent.phoneNumber || !isDomesticPhone(agent.phoneNumber))
+    ) {
+      throw new BadRequestException(
+        "This transit agent has no domestic phone number — the SMS gateway cannot reach it",
+      );
+    }
+
+    const sent = await this.customerResetService.sendResetLinkToUser(
+      agent.userId,
+      channel,
+      {
+        scope: `transit agent ${agent.id}`,
+        allowWithoutCredential: true,
+      },
+    );
+
+    if (!sent) {
+      throw new NotFoundException(
+        `No active account with ${
+          channel === ResetChannel.Email ? "an email address" : "a phone number"
+        } for this transit agent`,
+      );
+    }
+
+    return sent;
+  }
+
+  /** The transit agent signed in as `userId`, or null for any other account. */
+  findByUserId(userId: string): Promise<TransitAgent | null> {
+    return this.transitAgentsRepository.findByUserId(userId);
+  }
+
+  async update(
+    id: string,
+    dto: UpdateTransitAgentDto,
+  ): Promise<TransitAgentView> {
     const current = await this.findById(id);
     const nextValidFrom = dto.validFrom ?? current.validFrom;
     const nextValidTo = dto.validTo ?? current.validTo;
     if (nextValidTo < nextValidFrom) {
-      throw new BadRequestException('Valid-to date must be on or after valid-from date.');
+      throw new BadRequestException(
+        "Valid-to date must be on or after valid-from date.",
+      );
+    }
+
+    // `username` only ever names an IAM account, and it is chosen once at
+    // account creation. Accepting it here (PartialType inherits it from the
+    // create DTO) would write a column that does not exist on this table.
+    const { username: _ignoredUsername, email, phoneNumber, ...rest } = dto;
+
+    const contact: Partial<TransitAgent> = {};
+    if (email !== undefined) {
+      const normalized = email.trim().toLowerCase();
+      if (await this.transitAgentsRepository.existsByEmail(normalized, id)) {
+        throw new ConflictException(
+          `A transit agent with email ${normalized} already exists`,
+        );
+      }
+      contact.email = normalized;
+    }
+    if (phoneNumber !== undefined) {
+      contact.phoneNumber = phoneNumber.trim() || null;
     }
 
     const updated = await this.transitAgentsRepository.update(id, {
-      ...dto,
+      ...rest,
+      ...contact,
       ...(dto.name ? { name: dto.name.trim() } : {}),
     });
 
     if (!updated) {
       throw new NotFoundException(`Transit agent ${id} not found`);
     }
+
+    // Keep the IAM account in step. Without this, an agent whose address was
+    // corrected here would still receive its activation link at the old one —
+    // the reset service reads the address off `iam.users`, not off this row.
+    if (
+      updated.userId &&
+      (contact.email !== undefined || contact.phoneNumber !== undefined)
+    ) {
+      await this.syncIamContact(updated);
+    }
+
     return withValidityStatus(updated);
   }
 
+  /**
+   * Mirror an edited email/phone onto the linked IAM account.
+   *
+   * Best-effort: a failure here must not fail the agent edit that already
+   * committed, but it does mean the two are out of step, so it is logged loudly
+   * rather than swallowed. Re-running the edit retries it.
+   */
+  private async syncIamContact(agent: TransitAgent): Promise<void> {
+    if (!agent.userId) return;
+    try {
+      await this.userRepository.update(agent.userId, {
+        ...(agent.email ? { email: agent.email } : {}),
+        phoneNumber: agent.phoneNumber ?? undefined,
+      });
+    } catch (error) {
+      this.logger.error(
+        `Transit agent ${agent.id} contact updated but IAM user ${agent.userId} was not — ` +
+          `activation links will still go to the old address: ${String(error)}`,
+      );
+    }
+  }
+
   async remove(id: string): Promise<void> {
     await this.findById(id);
     await this.transitAgentsRepository.softDelete(id);
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/dto/create-transit-assignment.dto.ts b/apps/edr-freight-api/src/modules/transit-assignments/dto/create-transit-assignment.dto.ts
new file mode 100644
index 000000000..a21f75dd9
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/dto/create-transit-assignment.dto.ts
@@ -0,0 +1,36 @@
+import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
+import {
+  IsEnum,
+  IsOptional,
+  IsString,
+  IsUUID,
+  MaxLength,
+} from "class-validator";
+
+import { TransitAssignmentStatus } from "../entities/transit-assignment.entity";
+
+export class CreateTransitAssignmentDto {
+  @ApiProperty({ format: "uuid" })
+  @IsUUID()
+  bookingId!: string;
+
+  @ApiProperty({ format: "uuid" })
+  @IsUUID()
+  transitAgentId!: string;
+
+  @ApiPropertyOptional({
+    enum: TransitAssignmentStatus,
+    default: TransitAssignmentStatus.NotStarted,
+    description:
+      "Assignments normally start NOT_STARTED; pass one only to record work already under way.",
+  })
+  @IsOptional()
+  @IsEnum(TransitAssignmentStatus)
+  status?: TransitAssignmentStatus;
+
+  @ApiPropertyOptional({ maxLength: 2000 })
+  @IsOptional()
+  @IsString()
+  @MaxLength(2000)
+  note?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/dto/my-assignments-query.dto.ts b/apps/edr-freight-api/src/modules/transit-assignments/dto/my-assignments-query.dto.ts
new file mode 100644
index 000000000..4c7089780
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/dto/my-assignments-query.dto.ts
@@ -0,0 +1,43 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsEnum, IsInt, IsOptional, IsString, Max, Min } from "class-validator";
+
+import { TransitAssignmentStatus } from "../entities/transit-assignment.entity";
+
+/** Filters for the transit agent's own booking list. */
+export class MyAssignmentsQueryDto {
+  /** Free text over the booking reference and the customer's company name. */
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString()
+  search?: string;
+
+  @ApiPropertyOptional({ enum: TransitAssignmentStatus })
+  @IsOptional()
+  @IsEnum(TransitAssignmentStatus)
+  status?: TransitAssignmentStatus;
+
+  @ApiPropertyOptional({
+    example: "DISPATCHED",
+    description: "The booking's scheduling state.",
+  })
+  @IsOptional()
+  @IsString()
+  schedulingStatus?: string;
+
+  @ApiPropertyOptional({ default: 1 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  page?: number;
+
+  @ApiPropertyOptional({ default: 20 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  // Bounded so a hand-edited query string cannot ask for the whole table.
+  @Max(100)
+  pageSize?: number;
+}
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/dto/submit-transit-assignment.dto.ts b/apps/edr-freight-api/src/modules/transit-assignments/dto/submit-transit-assignment.dto.ts
new file mode 100644
index 000000000..f6e91cd31
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/dto/submit-transit-assignment.dto.ts
@@ -0,0 +1,23 @@
+import { ApiProperty, ApiPropertyOptional } from "@nestjs/swagger";
+import { Transform } from "class-transformer";
+import { IsBoolean, IsOptional, IsString, MaxLength } from "class-validator";
+
+/** The portal's Save / Finish action on the agent's own assignment. */
+export class SubmitTransitAssignmentDto {
+  @ApiProperty({
+    description:
+      "true finishes the assignment, which also locks its documents. false saves progress and leaves it open.",
+  })
+  // Arrives as a string when posted as multipart alongside files.
+  @Transform(({ value }) =>
+    value === "true" ? true : value === "false" ? false : value,
+  )
+  @IsBoolean()
+  finish!: boolean;
+
+  @ApiPropertyOptional({ maxLength: 2000 })
+  @IsOptional()
+  @IsString()
+  @MaxLength(2000)
+  note?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/dto/transit-assignment-query.dto.ts b/apps/edr-freight-api/src/modules/transit-assignments/dto/transit-assignment-query.dto.ts
new file mode 100644
index 000000000..166306f2a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/dto/transit-assignment-query.dto.ts
@@ -0,0 +1,36 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { Type } from "class-transformer";
+import { IsEnum, IsInt, IsOptional, IsUUID, Min } from "class-validator";
+
+import { TransitAssignmentStatus } from "../entities/transit-assignment.entity";
+
+export class TransitAssignmentQueryDto {
+  @ApiPropertyOptional({ format: "uuid" })
+  @IsOptional()
+  @IsUUID()
+  bookingId?: string;
+
+  @ApiPropertyOptional({ format: "uuid" })
+  @IsOptional()
+  @IsUUID()
+  transitAgentId?: string;
+
+  @ApiPropertyOptional({ enum: TransitAssignmentStatus })
+  @IsOptional()
+  @IsEnum(TransitAssignmentStatus)
+  status?: TransitAssignmentStatus;
+
+  @ApiPropertyOptional({ default: 1 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  page?: number;
+
+  @ApiPropertyOptional({ default: 20 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt()
+  @Min(1)
+  pageSize?: number;
+}
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/dto/update-transit-assignment.dto.ts b/apps/edr-freight-api/src/modules/transit-assignments/dto/update-transit-assignment.dto.ts
new file mode 100644
index 000000000..2dda6b34e
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/dto/update-transit-assignment.dto.ts
@@ -0,0 +1,22 @@
+import { ApiPropertyOptional } from "@nestjs/swagger";
+import { IsEnum, IsOptional, IsString, MaxLength } from "class-validator";
+
+import { TransitAssignmentStatus } from "../entities/transit-assignment.entity";
+
+/**
+ * `bookingId` and `transitAgentId` are absent on purpose: repointing an
+ * assignment at a different booking or agent would silently reattribute the
+ * work and the documents already filed under it. Delete and re-create instead.
+ */
+export class UpdateTransitAssignmentDto {
+  @ApiPropertyOptional({ enum: TransitAssignmentStatus })
+  @IsOptional()
+  @IsEnum(TransitAssignmentStatus)
+  status?: TransitAssignmentStatus;
+
+  @ApiPropertyOptional({ maxLength: 2000 })
+  @IsOptional()
+  @IsString()
+  @MaxLength(2000)
+  note?: string;
+}
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/entities/transit-assignment.entity.ts b/apps/edr-freight-api/src/modules/transit-assignments/entities/transit-assignment.entity.ts
new file mode 100644
index 000000000..dd7f07ac7
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/entities/transit-assignment.entity.ts
@@ -0,0 +1,79 @@
+import { BaseEntity } from "@edr/api-common";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+
+import { Booking } from "../../bookings/entities/booking.entity";
+import { TransitAgent } from "../../transit-agents/entities/transit-agent.entity";
+
+/** Where the agent's work on this booking currently stands. */
+export enum TransitAssignmentStatus {
+  NotStarted = "NOT_STARTED",
+  InProgress = "IN_PROGRESS",
+  Finished = "FINISHED",
+}
+
+/**
+ * One transit agent's work on one booking. An agent handles many bookings, so
+ * this is the join between the two, carrying the work's own state: when it
+ * started, when it finished, and the documents produced along the way.
+ *
+ * Deliberately separate from the transit-assignee handshake on the booking
+ * (`/bookings/:id/clearance/transit-assignee/...`), which is a pre-declaration
+ * agreement between GL Ethiopia and GL Djibouti about WHO will handle customs.
+ * Nothing here reads or writes that flow.
+ *
+ * There is no stored duration. "Time after the train arrives" is
+ * `finishedAt − booking.arrivedAt`; both halves already exist, and storing the
+ * difference would be a third source of truth that goes stale the moment either
+ * timestamp is corrected. It is computed on read — see
+ * `TransitAssignmentsService.toView`.
+ *
+ * Documents live in `freight.files` under
+ * {@link TRANSIT_ASSIGNMENT_FILE_RESOURCE}, which already carries the MinIO
+ * object, the upload time, the uploader and the supersede history.
+ */
+@Entity({ schema: "freight", name: "transit_assignments" })
+@Index(["bookingId"])
+@Index(["transitAgentId", "status"])
+export class TransitAssignment extends BaseEntity {
+  @Column({ name: "booking_id", type: "uuid" })
+  bookingId!: string;
+
+  @ManyToOne(() => Booking)
+  @JoinColumn({ name: "booking_id" })
+  booking?: Booking;
+
+  @Column({ name: "transit_agent_id", type: "uuid" })
+  transitAgentId!: string;
+
+  @ManyToOne(() => TransitAgent)
+  @JoinColumn({ name: "transit_agent_id" })
+  transitAgent?: TransitAgent;
+
+  @Column({
+    name: "status",
+    type: "varchar",
+    length: 32,
+    default: TransitAssignmentStatus.NotStarted,
+  })
+  status!: TransitAssignmentStatus;
+
+  /** Stamped on the first move to IN_PROGRESS; never overwritten afterwards. */
+  @Column({ name: "started_at", type: "timestamptz", nullable: true })
+  startedAt?: Date | null;
+
+  /** Stamped on the move to FINISHED. Cleared if the work is reopened. */
+  @Column({ name: "finished_at", type: "timestamptz", nullable: true })
+  finishedAt?: Date | null;
+
+  @Column({ name: "assigned_by_user_id", type: "uuid", nullable: true })
+  assignedByUserId?: string | null;
+
+  @Column({ name: "assigned_at", type: "timestamptz", default: () => "now()" })
+  assignedAt!: Date;
+
+  @Column({ name: "note", type: "text", nullable: true })
+  note?: string | null;
+}
+
+/** `files.resource` value for documents attached to a transit assignment. */
+export const TRANSIT_ASSIGNMENT_FILE_RESOURCE = "transit_assignments";
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.controller.ts b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.controller.ts
new file mode 100644
index 000000000..76dd0eb9c
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.controller.ts
@@ -0,0 +1,255 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseUUIDPipe,
+  Patch,
+  Post,
+  Query,
+  UploadedFiles,
+  UseInterceptors,
+} from "@nestjs/common";
+import { AnyFilesInterceptor } from "@nestjs/platform-express";
+import {
+  ApiBearerAuth,
+  ApiConsumes,
+  ApiOperation,
+  ApiTags,
+} from "@nestjs/swagger";
+
+import { CurrentUser } from "@edr/api-common";
+import type { TCurrentUser } from "@tria-plc/api-common/modules/auth/types/current-user.type";
+
+import { BookingStaff, PortalCustomer } from "../../common/booking-guards";
+import { documentUploadMulterOptions } from "../../common/document-upload.options";
+import { FREIGHT_PERMS } from "../../seed/freight-permissions.registry";
+import { CreateTransitAssignmentDto } from "./dto/create-transit-assignment.dto";
+import { MyAssignmentsQueryDto } from "./dto/my-assignments-query.dto";
+import { SubmitTransitAssignmentDto } from "./dto/submit-transit-assignment.dto";
+import { TransitAssignmentQueryDto } from "./dto/transit-assignment-query.dto";
+import { UpdateTransitAssignmentDto } from "./dto/update-transit-assignment.dto";
+import { TransitAssignmentsService } from "./transit-assignments.service";
+
+/**
+ * Transit assignments — one transit agent's work on one booking.
+ *
+ * Distinct from the transit-assignee handshake under
+ * `/bookings/:id/clearance/transit-assignee/...`, which decides WHO will handle
+ * a shipment's customs. This is the work record that follows: status, timings
+ * and documents.
+ */
+@ApiTags("transit-assignments")
+@Controller("transit-assignments")
+@ApiBearerAuth()
+export class TransitAssignmentsController {
+  constructor(
+    private readonly transitAssignmentsService: TransitAssignmentsService,
+  ) {}
+
+  // ── Portal — the signed-in transit agent's own work ───────────────────────
+  // Declared first so the literal `my` segment is matched before `:id`.
+  // Every route resolves the agent from the session; none accepts an agent id.
+
+  @Get("my/stats")
+  @PortalCustomer()
+  @ApiOperation({
+    summary: "Dashboard figures for the signed-in transit agent's own work",
+  })
+  myStats(@CurrentUser() user: TCurrentUser) {
+    return this.transitAssignmentsService.myStats(user.id);
+  }
+
+  @Get("my")
+  @PortalCustomer()
+  @ApiOperation({
+    summary:
+      "The signed-in transit agent's assigned bookings (paginated, filterable)",
+  })
+  findMine(
+    @CurrentUser() user: TCurrentUser,
+    @Query() query: MyAssignmentsQueryDto,
+  ) {
+    return this.transitAssignmentsService.findMine(user.id, query);
+  }
+
+  @Get("my/:id")
+  @PortalCustomer()
+  @ApiOperation({ summary: "One of my assignments, with its documents" })
+  findMineById(
+    @CurrentUser() user: TCurrentUser,
+    @Param("id", ParseUUIDPipe) id: string,
+  ) {
+    return this.transitAssignmentsService.findMineById(user.id, id);
+  }
+
+  @Post("my/:id/files")
+  @PortalCustomer()
+  @ApiConsumes("multipart/form-data")
+  @UseInterceptors(AnyFilesInterceptor(documentUploadMulterOptions))
+  @ApiOperation({
+    summary:
+      "Upload documents to my assignment. Allowed only while the booking is DISPATCHED and the assignment is not finished.",
+  })
+  uploadMyFiles(
+    @CurrentUser() user: TCurrentUser,
+    @Param("id", ParseUUIDPipe) id: string,
+    @UploadedFiles() files: Express.Multer.File[],
+    // One `titles` part per file, in the same order. A single-file upload posts
+    // one part, which multipart parsing hands back as a bare string rather than
+    // an array — normalised here so the service always sees a positional list.
+    @Body("titles") titles?: string | string[],
+  ) {
+    return this.transitAssignmentsService.uploadMyFiles(
+      user.id,
+      id,
+      files,
+      { userId: user.id, name: user.name?.en ?? undefined },
+      titles === undefined ? undefined : ([] as string[]).concat(titles),
+    );
+  }
+
+  @Delete("my/:id/files/:fileId")
+  @PortalCustomer()
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: "Remove a document from my assignment" })
+  removeMyFile(
+    @CurrentUser() user: TCurrentUser,
+    @Param("id", ParseUUIDPipe) id: string,
+    @Param("fileId", ParseUUIDPipe) fileId: string,
+  ) {
+    return this.transitAssignmentsService.removeMyFile(user.id, id, fileId);
+  }
+
+  @Post("my/:id/submit")
+  @PortalCustomer()
+  @ApiOperation({
+    summary:
+      "Save progress, or finish the assignment (which locks its documents)",
+  })
+  submitMine(
+    @CurrentUser() user: TCurrentUser,
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: SubmitTransitAssignmentDto,
+  ) {
+    return this.transitAssignmentsService.submitMine(user.id, id, dto);
+  }
+
+  // ── Backoffice ────────────────────────────────────────────────────────────
+
+  @Get()
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.view)
+  @ApiOperation({
+    summary:
+      "List transit assignments (paginated, filterable by booking / agent / status)",
+  })
+  findAll(@Query() query: TransitAssignmentQueryDto) {
+    return this.transitAssignmentsService.findAll(query);
+  }
+
+  /**
+   * Declared before `:id` — Nest matches routes in order, so a literal segment
+   * registered after a parameter would be swallowed by it.
+   */
+  @Get("by-agent/:transitAgentId")
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.view)
+  @ApiOperation({ summary: "Every assignment handed to one transit agent" })
+  findByTransitAgent(
+    @Param("transitAgentId", ParseUUIDPipe) transitAgentId: string,
+  ) {
+    return this.transitAssignmentsService.findByTransitAgent(transitAgentId);
+  }
+
+  @Get("by-booking/:bookingId")
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.view)
+  @ApiOperation({ summary: "Every transit agent assigned to one booking" })
+  findByBooking(@Param("bookingId", ParseUUIDPipe) bookingId: string) {
+    return this.transitAssignmentsService.findByBooking(bookingId);
+  }
+
+  @Get(":id")
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.view)
+  @ApiOperation({
+    summary:
+      "One assignment, with its attached documents and computed duration",
+  })
+  findOne(@Param("id", ParseUUIDPipe) id: string) {
+    return this.transitAssignmentsService.findById(id);
+  }
+
+  @Post()
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.create)
+  @ApiOperation({ summary: "Assign a transit agent to a booking" })
+  create(
+    @Body() dto: CreateTransitAssignmentDto,
+    @CurrentUser() user: TCurrentUser,
+  ) {
+    return this.transitAssignmentsService.create(dto, user?.id);
+  }
+
+  @Patch(":id")
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.update)
+  @ApiOperation({
+    summary:
+      "Update status or note — status changes stamp the start/finish clocks",
+  })
+  update(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Body() dto: UpdateTransitAssignmentDto,
+  ) {
+    return this.transitAssignmentsService.update(id, dto);
+  }
+
+  @Delete(":id")
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.delete)
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: "Soft-delete an assignment" })
+  remove(@Param("id", ParseUUIDPipe) id: string) {
+    return this.transitAssignmentsService.remove(id);
+  }
+
+  // ── Documents ─────────────────────────────────────────────────────────────
+
+  @Get(":id/files")
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.view)
+  @ApiOperation({ summary: "An assignment's uploaded documents" })
+  listFiles(@Param("id", ParseUUIDPipe) id: string) {
+    return this.transitAssignmentsService.listFiles(id);
+  }
+
+  @Post(":id/files")
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.update)
+  @ApiConsumes("multipart/form-data")
+  @UseInterceptors(AnyFilesInterceptor(documentUploadMulterOptions))
+  @ApiOperation({
+    summary:
+      "Upload one or more documents; re-uploading adds a version, it does not overwrite",
+  })
+  uploadFiles(
+    @Param("id", ParseUUIDPipe) id: string,
+    @UploadedFiles() files: Express.Multer.File[],
+    @CurrentUser() user: TCurrentUser,
+    @Body("titles") titles?: string | string[],
+  ) {
+    return this.transitAssignmentsService.uploadFiles(
+      id,
+      files,
+      { userId: user?.id, name: user?.name?.en ?? undefined },
+      titles === undefined ? undefined : ([] as string[]).concat(titles),
+    );
+  }
+
+  @Delete(":id/files/:fileId")
+  @BookingStaff(FREIGHT_PERMS.transitAssignments.update)
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: "Remove one document from an assignment" })
+  removeFile(
+    @Param("id", ParseUUIDPipe) id: string,
+    @Param("fileId", ParseUUIDPipe) fileId: string,
+  ) {
+    return this.transitAssignmentsService.removeFile(id, fileId);
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.module.ts b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.module.ts
new file mode 100644
index 000000000..65edc5868
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.module.ts
@@ -0,0 +1,25 @@
+import { Module } from "@nestjs/common";
+import { TypeOrmModule } from "@nestjs/typeorm";
+
+import { Booking } from "../bookings/entities/booking.entity";
+import { FilesModule } from "../files/files.module";
+import { TransitAgentsModule } from "../transit-agents/transit-agents.module";
+import { TransitAssignment } from "./entities/transit-assignment.entity";
+import { TransitAssignmentsController } from "./transit-assignments.controller";
+import { TransitAssignmentsRepository } from "./transit-assignments.repository";
+import { TransitAssignmentsService } from "./transit-assignments.service";
+
+@Module({
+  imports: [
+    // `Booking` is registered as an ENTITY rather than importing BookingsModule:
+    // this module only confirms a booking id exists, and that module would drag
+    // its whole graph (billing, contracts, scheduling, first/last mile) along.
+    TypeOrmModule.forFeature([TransitAssignment, Booking]),
+    FilesModule,
+    TransitAgentsModule,
+  ],
+  controllers: [TransitAssignmentsController],
+  providers: [TransitAssignmentsService, TransitAssignmentsRepository],
+  exports: [TransitAssignmentsService, TransitAssignmentsRepository],
+})
+export class TransitAssignmentsModule {}
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.repository.ts b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.repository.ts
new file mode 100644
index 000000000..9030d58f7
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.repository.ts
@@ -0,0 +1,139 @@
+import { BaseRepository } from "@edr/api-common";
+import { Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+
+import {
+  TransitAssignment,
+  TransitAssignmentStatus,
+} from "./entities/transit-assignment.entity";
+
+export interface TransitAssignmentFilter {
+  bookingId?: string;
+  transitAgentId?: string;
+  status?: TransitAssignmentStatus;
+  /** The booking's scheduling state (DISPATCHED / SCHEDULED / …). */
+  schedulingStatus?: string;
+  /** Free text over the booking reference and the customer's company name. */
+  search?: string;
+}
+
+@Injectable()
+export class TransitAssignmentsRepository extends BaseRepository<TransitAssignment> {
+  constructor(
+    @InjectRepository(TransitAssignment)
+    private readonly assignmentsRepo: Repository<TransitAssignment>,
+  ) {
+    super(assignmentsRepo);
+  }
+
+  /**
+   * The booking is joined rather than lazily loaded because every read needs
+   * its `arrivedAt` — that is the other half of the computed
+   * "time after the train arrives", so a list without it would be N+1 queries
+   * or a column of nulls. The customer's company rides along for the same
+   * reason: the agent's list is read by reference AND by whose cargo it is.
+   */
+  private baseQuery() {
+    return this.assignmentsRepo
+      .createQueryBuilder("ta")
+      .leftJoinAndSelect("ta.booking", "booking")
+      .leftJoinAndSelect("booking.company", "company")
+      .leftJoinAndSelect("ta.transitAgent", "agent")
+      .where("ta.deletedAt IS NULL");
+  }
+
+  /** Shared filter application, so a list and its count can never diverge. */
+  private applyFilters(
+    qb: ReturnType<TransitAssignmentsRepository["baseQuery"]>,
+    filter: TransitAssignmentFilter,
+  ) {
+    if (filter.bookingId) {
+      qb.andWhere("ta.bookingId = :bookingId", { bookingId: filter.bookingId });
+    }
+    if (filter.transitAgentId) {
+      qb.andWhere("ta.transitAgentId = :transitAgentId", {
+        transitAgentId: filter.transitAgentId,
+      });
+    }
+    if (filter.status) {
+      qb.andWhere("ta.status = :status", { status: filter.status });
+    }
+    if (filter.schedulingStatus) {
+      qb.andWhere("booking.schedulingStatus = :schedulingStatus", {
+        schedulingStatus: filter.schedulingStatus,
+      });
+    }
+    if (filter.search?.trim()) {
+      qb.andWhere(
+        "(booking.reference ILIKE :search OR company.name ILIKE :search)",
+        { search: `%${filter.search.trim()}%` },
+      );
+    }
+    return qb;
+  }
+
+  async findPaginated(
+    filter: TransitAssignmentFilter,
+    skip: number,
+    take: number,
+  ): Promise<[TransitAssignment[], number]> {
+    return this.applyFilters(this.baseQuery(), filter)
+      .orderBy("ta.assignedAt", "DESC")
+      .skip(skip)
+      .take(take)
+      .getManyAndCount();
+  }
+
+  /**
+   * One agent's own list, filtered and paginated. Differs from
+   * {@link findPaginated} only in that the agent is pinned by the caller from
+   * the session, so it can never be widened by a query parameter.
+   */
+  async findByTransitAgentPaginated(
+    transitAgentId: string,
+    filter: Omit<TransitAssignmentFilter, "transitAgentId">,
+    skip: number,
+    take: number,
+  ): Promise<[TransitAssignment[], number]> {
+    return this.applyFilters(this.baseQuery(), { ...filter, transitAgentId })
+      .orderBy("ta.assignedAt", "DESC")
+      .skip(skip)
+      .take(take)
+      .getManyAndCount();
+  }
+
+  findOneWithRelations(id: string): Promise<TransitAssignment | null> {
+    return this.baseQuery().andWhere("ta.id = :id", { id }).getOne();
+  }
+
+  /** Every live assignment for one agent — the agent's own workload list. */
+  findByTransitAgent(transitAgentId: string): Promise<TransitAssignment[]> {
+    return this.baseQuery()
+      .andWhere("ta.transitAgentId = :transitAgentId", { transitAgentId })
+      .orderBy("ta.assignedAt", "DESC")
+      .getMany();
+  }
+
+  /** Every live assignment on one booking. */
+  findByBooking(bookingId: string): Promise<TransitAssignment[]> {
+    return this.baseQuery()
+      .andWhere("ta.bookingId = :bookingId", { bookingId })
+      .orderBy("ta.assignedAt", "DESC")
+      .getMany();
+  }
+
+  /** Guards the unique (booking, agent) pair before an insert 23505s. */
+  async existsForPair(
+    bookingId: string,
+    transitAgentId: string,
+  ): Promise<boolean> {
+    const count = await this.assignmentsRepo
+      .createQueryBuilder("ta")
+      .where("ta.bookingId = :bookingId", { bookingId })
+      .andWhere("ta.transitAgentId = :transitAgentId", { transitAgentId })
+      .andWhere("ta.deletedAt IS NULL")
+      .getCount();
+    return count > 0;
+  }
+}
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.service.spec.ts b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.service.spec.ts
new file mode 100644
index 000000000..f23a8426a
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.service.spec.ts
@@ -0,0 +1,515 @@
+import {
+  ConflictException,
+  ForbiddenException,
+  NotFoundException,
+} from "@nestjs/common";
+
+import {
+  TransitAssignment,
+  TransitAssignmentStatus,
+} from "./entities/transit-assignment.entity";
+import { TransitAssignmentsService } from "./transit-assignments.service";
+
+/**
+ * The two things this module gets wrong quietly: the status transitions that
+ * stamp the clocks, and the duration computed from them. Both are invisible
+ * until a report reads a null or a negative number months later.
+ */
+describe("TransitAssignmentsService", () => {
+  const ARRIVED = new Date("2026-08-28T09:00:00Z");
+
+  let assignments: {
+    findPaginated: jest.Mock;
+    findOneWithRelations: jest.Mock;
+    findByTransitAgent: jest.Mock;
+    findByTransitAgentPaginated: jest.Mock;
+    findByBooking: jest.Mock;
+    existsForPair: jest.Mock;
+    create: jest.Mock;
+    update: jest.Mock;
+    softDelete: jest.Mock;
+  };
+  let agents: { findById: jest.Mock; findByUserId: jest.Mock };
+  let bookings: { findOne: jest.Mock };
+  let files: {
+    findByResource: jest.Mock;
+    findByResourceIdsGrouped: jest.Mock;
+    upload: jest.Mock;
+    remove: jest.Mock;
+  };
+  let service: TransitAssignmentsService;
+
+  const row = (over: Partial<TransitAssignment> = {}) =>
+    ({
+      id: "ta-1",
+      bookingId: "bk-1",
+      transitAgentId: "ag-1",
+      status: TransitAssignmentStatus.NotStarted,
+      startedAt: null,
+      finishedAt: null,
+      // DISPATCHED by default: uploads are gated on it, so a fixture without it
+      // would fail every document test for the wrong reason.
+      booking: {
+        id: "bk-1",
+        arrivedAt: ARRIVED,
+        schedulingStatus: "DISPATCHED",
+      },
+      ...over,
+    }) as TransitAssignment;
+
+  beforeEach(() => {
+    assignments = {
+      findPaginated: jest.fn(),
+      findOneWithRelations: jest.fn().mockResolvedValue(row()),
+      findByTransitAgent: jest.fn().mockResolvedValue([]),
+      findByTransitAgentPaginated: jest.fn().mockResolvedValue([[], 0]),
+      findByBooking: jest.fn().mockResolvedValue([]),
+      existsForPair: jest.fn().mockResolvedValue(false),
+      create: jest.fn(async (data) => ({ id: "ta-1", ...data })),
+      update: jest.fn(async (id, data) => ({ id, ...data })),
+      softDelete: jest.fn(),
+    };
+    agents = {
+      findById: jest.fn().mockResolvedValue({ id: "ag-1", name: "Ahmed" }),
+      findByUserId: jest.fn().mockResolvedValue({ id: "ag-1", name: "Ahmed" }),
+    };
+    bookings = { findOne: jest.fn().mockResolvedValue({ id: "bk-1" }) };
+    files = {
+      findByResource: jest.fn().mockResolvedValue([]),
+      findByResourceIdsGrouped: jest.fn().mockResolvedValue(new Map()),
+      upload: jest.fn(),
+      remove: jest.fn(),
+    };
+
+    service = new TransitAssignmentsService(
+      assignments as never,
+      agents as never,
+      bookings as never,
+      files as never,
+    );
+  });
+
+  describe("timeAfterTrainArrives", () => {
+    it("reports whole minutes between arrival and finish", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: new Date("2026-08-28T14:30:00Z"),
+        }),
+      );
+
+      const view = await service.findById("ta-1");
+
+      expect(view.timeAfterTrainArrives).toBe(330);
+    });
+
+    it("is null while the work is unfinished", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({ status: TransitAssignmentStatus.InProgress, startedAt: ARRIVED }),
+      );
+
+      expect((await service.findById("ta-1")).timeAfterTrainArrives).toBeNull();
+    });
+
+    it("is null when the booking never recorded an arrival", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: new Date("2026-08-28T14:30:00Z"),
+          booking: {
+            id: "bk-1",
+            arrivedAt: null,
+            schedulingStatus: "DISPATCHED",
+          } as never,
+        }),
+      );
+
+      expect((await service.findById("ta-1")).timeAfterTrainArrives).toBeNull();
+    });
+  });
+
+  describe("status transitions", () => {
+    it("stamps startedAt on the move to IN_PROGRESS", async () => {
+      await service.update("ta-1", {
+        status: TransitAssignmentStatus.InProgress,
+      });
+
+      const patch = assignments.update.mock.calls[0][1];
+      expect(patch.startedAt).toBeInstanceOf(Date);
+      expect(patch.finishedAt).toBeNull();
+    });
+
+    it("keeps the ORIGINAL startedAt when finished work is reopened", async () => {
+      const original = new Date("2026-08-28T10:00:00Z");
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          status: TransitAssignmentStatus.Finished,
+          startedAt: original,
+          finishedAt: new Date("2026-08-28T12:00:00Z"),
+        }),
+      );
+
+      await service.update("ta-1", {
+        status: TransitAssignmentStatus.InProgress,
+      });
+
+      const patch = assignments.update.mock.calls[0][1];
+      // Reopening must not restart the clock, or the elapsed time would only
+      // cover the second attempt rather than the whole job.
+      expect(patch.startedAt).toBe(original);
+      expect(patch.finishedAt).toBeNull();
+    });
+
+    it("stamps both clocks when finishing work that was never started", async () => {
+      await service.update("ta-1", {
+        status: TransitAssignmentStatus.Finished,
+      });
+
+      const patch = assignments.update.mock.calls[0][1];
+      expect(patch.startedAt).toBeInstanceOf(Date);
+      expect(patch.finishedAt).toBeInstanceOf(Date);
+    });
+
+    it("clears both clocks on a reset to NOT_STARTED", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          status: TransitAssignmentStatus.Finished,
+          startedAt: ARRIVED,
+          finishedAt: new Date(),
+        }),
+      );
+
+      await service.update("ta-1", {
+        status: TransitAssignmentStatus.NotStarted,
+      });
+
+      const patch = assignments.update.mock.calls[0][1];
+      expect(patch.startedAt).toBeNull();
+      expect(patch.finishedAt).toBeNull();
+    });
+  });
+
+  describe("create", () => {
+    it("refuses to assign the same agent to one booking twice", async () => {
+      assignments.existsForPair.mockResolvedValue(true);
+
+      await expect(
+        service.create({ bookingId: "bk-1", transitAgentId: "ag-1" }),
+      ).rejects.toThrow(ConflictException);
+      expect(assignments.create).not.toHaveBeenCalled();
+    });
+
+    it("rejects an unknown booking", async () => {
+      bookings.findOne.mockResolvedValue(null);
+
+      await expect(
+        service.create({ bookingId: "nope", transitAgentId: "ag-1" }),
+      ).rejects.toThrow(NotFoundException);
+    });
+  });
+
+  describe("files", () => {
+    it("refuses to delete a file belonging to another assignment", async () => {
+      files.findByResource.mockResolvedValue([{ id: "file-1" }]);
+
+      await expect(service.removeFile("ta-1", "file-2")).rejects.toThrow(
+        NotFoundException,
+      );
+      expect(files.remove).not.toHaveBeenCalled();
+    });
+
+    it("names each uploaded file from its positional title", async () => {
+      await service.uploadFiles(
+        "ta-1",
+        [
+          { originalname: "a.pdf" } as Express.Multer.File,
+          { originalname: "b.pdf" } as Express.Multer.File,
+          { originalname: "c.pdf" } as Express.Multer.File,
+        ],
+        {},
+        ["Bill of lading", "  ", "Packing list"],
+      );
+
+      const titles = files.upload.mock.calls.map((call) => call[0].title);
+      // Index N names file N; a blank entry falls back to null so the record
+      // shows its original filename rather than an empty label.
+      expect(titles).toEqual(["Bill of lading", null, "Packing list"]);
+    });
+
+    it("stores no title when none were sent", async () => {
+      await service.uploadFiles(
+        "ta-1",
+        [{ originalname: "a.pdf" } as Express.Multer.File],
+        {},
+      );
+
+      expect(files.upload.mock.calls[0][0].title).toBeNull();
+    });
+
+    it("refuses an upload before the booking is dispatched", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          booking: {
+            id: "bk-1",
+            arrivedAt: null,
+            schedulingStatus: "SCHEDULED",
+          } as never,
+        }),
+      );
+
+      await expect(
+        service.uploadFiles("ta-1", [{} as Express.Multer.File], {}),
+      ).rejects.toThrow(ForbiddenException);
+      expect(files.upload).not.toHaveBeenCalled();
+    });
+
+    it("refuses an upload once the assignment is finished", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: new Date(),
+        }),
+      );
+
+      await expect(
+        service.uploadFiles("ta-1", [{} as Express.Multer.File], {}),
+      ).rejects.toThrow(ForbiddenException);
+    });
+
+    it("refuses to remove a document once the assignment is finished", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: new Date(),
+        }),
+      );
+      files.findByResource.mockResolvedValue([{ id: "file-1" }]);
+
+      await expect(service.removeFile("ta-1", "file-1")).rejects.toThrow(
+        ForbiddenException,
+      );
+      expect(files.remove).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("myStats", () => {
+    const at = (iso: string) => new Date(iso);
+
+    const withRows = (rows: Record<string, unknown>[]) => {
+      assignments.findByTransitAgent.mockResolvedValue(
+        rows.map((r, i) => row({ id: `ta-${i}`, ...r } as never)),
+      );
+      files.findByResourceIdsGrouped.mockResolvedValue(new Map());
+    };
+
+    it("uses the median, so one reopened assignment cannot skew the headline", async () => {
+      withRows([
+        {
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: at("2026-08-28T10:35:00Z"),
+        },
+        {
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: at("2026-08-28T12:10:00Z"),
+        },
+        {
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: at("2026-08-28T13:45:00Z"),
+        },
+        // 47h outlier: a mean would report ~12h, which describes nobody.
+        {
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: at("2026-08-30T08:00:00Z"),
+        },
+      ]);
+
+      const stats = await service.myStats("user-1");
+
+      // 95/190/285/2820 -> even count, so the median averages the middle two.
+      // A mean would be 848 minutes, describing none of the four.
+      expect(stats.performance.medianClearanceMinutes).toBe(238);
+      expect(stats.performance.slowestClearanceMinutes).toBe(2820);
+    });
+
+    it("bands clearance times into the SLA buckets", async () => {
+      withRows([
+        {
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: at("2026-08-28T10:30:00Z"),
+        },
+        {
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: at("2026-08-28T13:00:00Z"),
+        },
+        {
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: at("2026-08-29T09:00:00Z"),
+        },
+      ]);
+
+      const stats = await service.myStats("user-1");
+
+      expect(stats.sla).toEqual({ under2h: 1, under6h: 1, over6h: 1 });
+      expect(stats.performance.onTimeRate).toBe(67);
+    });
+
+    it("counts coverage only over dispatched bookings", async () => {
+      withRows([
+        { booking: { arrivedAt: null, schedulingStatus: "DISPATCHED" } },
+        { booking: { arrivedAt: null, schedulingStatus: "DISPATCHED" } },
+        // Scheduled bookings cannot receive documents yet, so counting them
+        // would report a failure the agent could not have avoided.
+        { booking: { arrivedAt: null, schedulingStatus: "SCHEDULED" } },
+      ]);
+
+      const stats = await service.myStats("user-1");
+
+      expect(stats.coverage.dispatched).toBe(2);
+      expect(stats.coverage.withDocuments).toBe(0);
+    });
+
+    it("reports nulls rather than zero when nothing has been measured", async () => {
+      withRows([{ status: TransitAssignmentStatus.NotStarted }]);
+
+      const stats = await service.myStats("user-1");
+
+      expect(stats.performance.medianClearanceMinutes).toBeNull();
+      expect(stats.performance.onTimeRate).toBeNull();
+      expect(stats.totals.open).toBe(1);
+    });
+  });
+
+  describe("customerName", () => {
+    it("flattens the booking's company name", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          booking: {
+            id: "bk-1",
+            arrivedAt: ARRIVED,
+            schedulingStatus: "DISPATCHED",
+            company: { name: "SHAFICI PHARMACEUTICAL" },
+          } as never,
+        }),
+      );
+
+      expect((await service.findById("ta-1")).customerName).toBe(
+        "SHAFICI PHARMACEUTICAL",
+      );
+    });
+
+    it("is null when the booking has no company", async () => {
+      expect((await service.findById("ta-1")).customerName).toBeNull();
+    });
+  });
+
+  describe("canUploadDocuments", () => {
+    it("is true for an open assignment on a dispatched booking", async () => {
+      expect((await service.findById("ta-1")).canUploadDocuments).toBe(true);
+    });
+
+    it("is false before dispatch", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          booking: {
+            id: "bk-1",
+            arrivedAt: null,
+            schedulingStatus: "SCHEDULED",
+          } as never,
+        }),
+      );
+      expect((await service.findById("ta-1")).canUploadDocuments).toBe(false);
+    });
+
+    it("is false once finished", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: new Date(),
+        }),
+      );
+      expect((await service.findById("ta-1")).canUploadDocuments).toBe(false);
+    });
+  });
+
+  describe("portal scoping", () => {
+    it("hides another agent's assignment behind a NotFound", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({ transitAgentId: "someone-else" }),
+      );
+
+      await expect(service.findMineById("user-1", "ta-1")).rejects.toThrow(
+        NotFoundException,
+      );
+    });
+
+    it("rejects an account that is not a transit agent", async () => {
+      agents.findByUserId.mockResolvedValue(null);
+
+      await expect(service.findMine("user-1")).rejects.toThrow(
+        ForbiddenException,
+      );
+    });
+
+    it("pins the query to the session's agent and passes the filters through", async () => {
+      await service.findMine("user-1", {
+        search: "BK-2026",
+        status: TransitAssignmentStatus.InProgress,
+        schedulingStatus: "DISPATCHED",
+        page: 2,
+        pageSize: 10,
+      });
+
+      const [agentId, filter, skip, take] =
+        assignments.findByTransitAgentPaginated.mock.calls[0];
+      // The agent id comes from the session, never from the query — otherwise
+      // one agent could page through another agent's work.
+      expect(agentId).toBe("ag-1");
+      expect(filter).toMatchObject({
+        search: "BK-2026",
+        status: TransitAssignmentStatus.InProgress,
+        schedulingStatus: "DISPATCHED",
+      });
+      expect(skip).toBe(10);
+      expect(take).toBe(10);
+    });
+
+    it("reports pagination meta", async () => {
+      assignments.findByTransitAgentPaginated.mockResolvedValue([[], 45]);
+
+      const result = await service.findMine("user-1", { pageSize: 20 });
+
+      expect(result.meta).toEqual({
+        total: 45,
+        page: 1,
+        pageSize: 20,
+        totalPages: 3,
+      });
+    });
+
+    it("save moves the assignment to IN_PROGRESS, finish closes it", async () => {
+      await service.submitMine("user-1", "ta-1", { finish: false });
+      expect(assignments.update.mock.calls[0][1].status).toBe(
+        TransitAssignmentStatus.InProgress,
+      );
+
+      assignments.update.mockClear();
+      await service.submitMine("user-1", "ta-1", { finish: true });
+      expect(assignments.update.mock.calls[0][1].status).toBe(
+        TransitAssignmentStatus.Finished,
+      );
+    });
+
+    it("refuses to re-submit an already finished assignment", async () => {
+      assignments.findOneWithRelations.mockResolvedValue(
+        row({
+          status: TransitAssignmentStatus.Finished,
+          finishedAt: new Date(),
+        }),
+      );
+
+      await expect(
+        service.submitMine("user-1", "ta-1", { finish: true }),
+      ).rejects.toThrow(ForbiddenException);
+    });
+  });
+});
diff --git a/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.service.ts b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.service.ts
new file mode 100644
index 000000000..389e08fac
--- /dev/null
+++ b/apps/edr-freight-api/src/modules/transit-assignments/transit-assignments.service.ts
@@ -0,0 +1,596 @@
+import {
+  BadRequestException,
+  ConflictException,
+  ForbiddenException,
+  Injectable,
+  NotFoundException,
+} from "@nestjs/common";
+
+import { InjectRepository } from "@nestjs/typeorm";
+import { Repository } from "typeorm";
+
+import { Booking } from "../bookings/entities/booking.entity";
+import { FilesService } from "../files/files.service";
+import { TransitAgentsRepository } from "../transit-agents/transit-agents.repository";
+import { FileRecord } from "../files/entities/file.entity";
+import { CreateTransitAssignmentDto } from "./dto/create-transit-assignment.dto";
+import { MyAssignmentsQueryDto } from "./dto/my-assignments-query.dto";
+import { TransitAssignmentQueryDto } from "./dto/transit-assignment-query.dto";
+import { UpdateTransitAssignmentDto } from "./dto/update-transit-assignment.dto";
+import {
+  TRANSIT_ASSIGNMENT_FILE_RESOURCE,
+  TransitAssignment,
+  TransitAssignmentStatus,
+} from "./entities/transit-assignment.entity";
+import { TransitAssignmentsRepository } from "./transit-assignments.repository";
+
+/** One attached document, flattened for the API. */
+export interface TransitAssignmentFileView {
+  id: string;
+  name: string;
+  title: string | null;
+  url: string;
+  size: number;
+  mimeType: string;
+  /** When the file was first uploaded. */
+  uploadedAt: string;
+  /** When its metadata was last edited — equal to `uploadedAt` if never. */
+  updatedAt: string;
+  uploadedByUserId: string | null;
+  uploadedByName: string | null;
+}
+
+export type TransitAssignmentView = TransitAssignment & {
+  /**
+   * Minutes between the train arriving and the transit work finishing —
+   * `finishedAt − booking.arrivedAt`, floored to whole minutes.
+   *
+   * Null until BOTH exist: an unfinished assignment has no end, and a booking
+   * whose arrival was never stamped has no start. Computed rather than stored
+   * so a corrected timestamp cannot leave a stale number behind.
+   */
+  timeAfterTrainArrives: number | null;
+  /**
+   * Whether documents may still be added or removed right now. Mirrors
+   * `assertUploadAllowed` so the portal can disable its controls instead of
+   * letting the agent discover the rule through a 403.
+   */
+  canUploadDocuments: boolean;
+  /**
+   * Whose cargo this is. Flattened off the joined company so the portal grid
+   * does not have to reach through `booking.company` — and so a booking with no
+   * company (shipping-line bookings carry none) renders as a blank rather than
+   * throwing.
+   */
+  customerName: string | null;
+  files?: TransitAssignmentFileView[];
+};
+
+@Injectable()
+export class TransitAssignmentsService {
+  constructor(
+    private readonly assignmentsRepository: TransitAssignmentsRepository,
+    private readonly transitAgentsRepository: TransitAgentsRepository,
+    // The Booking ENTITY, not BookingsModule: this only needs to confirm a
+    // booking id exists, and importing that module would pull its whole graph
+    // (billing, contracts, scheduling, first/last mile) in behind it.
+    @InjectRepository(Booking)
+    private readonly bookingsRepository: Repository<Booking>,
+    private readonly filesService: FilesService,
+  ) {}
+
+  private static minutesBetween(
+    from?: Date | null,
+    to?: Date | null,
+  ): number | null {
+    if (!from || !to) return null;
+    return Math.floor((to.getTime() - from.getTime()) / 60_000);
+  }
+
+  private toView(assignment: TransitAssignment): TransitAssignmentView {
+    return {
+      ...assignment,
+      timeAfterTrainArrives: TransitAssignmentsService.minutesBetween(
+        assignment.booking?.arrivedAt,
+        assignment.finishedAt,
+      ),
+      canUploadDocuments:
+        assignment.status !== TransitAssignmentStatus.Finished &&
+        assignment.booking?.schedulingStatus === "DISPATCHED",
+      customerName: assignment.booking?.company?.name ?? null,
+    };
+  }
+
+  async findAll(query: TransitAssignmentQueryDto) {
+    const page = query.page ?? 1;
+    const pageSize = query.pageSize ?? 20;
+    const [items, total] = await this.assignmentsRepository.findPaginated(
+      {
+        bookingId: query.bookingId,
+        transitAgentId: query.transitAgentId,
+        status: query.status,
+      },
+      (page - 1) * pageSize,
+      pageSize,
+    );
+
+    return {
+      items: items.map((item) => this.toView(item)),
+      meta: {
+        total,
+        page,
+        pageSize,
+        totalPages: Math.max(1, Math.ceil(total / pageSize)),
+      },
+    };
+  }
+
+  /** Detail read — the only one that carries the attached documents. */
+  async findById(id: string): Promise<TransitAssignmentView> {
+    const assignment =
+      await this.assignmentsRepository.findOneWithRelations(id);
+    if (!assignment) {
+      throw new NotFoundException(`Transit assignment ${id} not found`);
+    }
+    return { ...this.toView(assignment), files: await this.listFiles(id) };
+  }
+
+  /** Every assignment handed to one transit agent — their workload list. */
+  async findByTransitAgent(
+    transitAgentId: string,
+  ): Promise<TransitAssignmentView[]> {
+    const agent = await this.transitAgentsRepository.findById(transitAgentId);
+    if (!agent) {
+      throw new NotFoundException(`Transit agent ${transitAgentId} not found`);
+    }
+    const rows =
+      await this.assignmentsRepository.findByTransitAgent(transitAgentId);
+    return rows.map((row) => this.toView(row));
+  }
+
+  /** Every agent assigned to one booking. */
+  async findByBooking(bookingId: string): Promise<TransitAssignmentView[]> {
+    const rows = await this.assignmentsRepository.findByBooking(bookingId);
+    return rows.map((row) => this.toView(row));
+  }
+
+  // ── Portal (the signed-in transit agent's own work) ───────────────────────
+  // Every one of these resolves the agent from the SESSION and never from a
+  // client-supplied id: an agent must not be able to read or edit another
+  // agent's assignments by guessing one.
+
+  /** The transit agent this portal user signs in as. */
+  private async requireAgentForUser(userId: string) {
+    const agent = await this.transitAgentsRepository.findByUserId(userId);
+    if (!agent) {
+      throw new ForbiddenException("This account is not a transit agent");
+    }
+    return agent;
+  }
+
+  /**
+   * Dashboard figures for the signed-in agent's own work.
+   *
+   * Every interval is derived from timestamps that already exist — nothing is
+   * stored, so a corrected arrival or finish time changes these on the next
+   * read rather than leaving a stale metric behind.
+   *
+   * The median is used rather than the mean on purpose: one assignment
+   * reopened days later drags an average far enough to make the whole panel
+   * lie about typical performance.
+   */
+  async myStats(userId: string) {
+    const agent = await this.requireAgentForUser(userId);
+    const rows = await this.assignmentsRepository.findByTransitAgent(agent.id);
+
+    const docCounts = rows.length
+      ? await this.filesService.findByResourceIdsGrouped(
+          rows.map((r) => r.id),
+          TRANSIT_ASSIGNMENT_FILE_RESOURCE,
+        )
+      : new Map<string, unknown[]>();
+
+    const minutes = (from?: Date | null, to?: Date | null) =>
+      from && to ? Math.floor((to.getTime() - from.getTime()) / 60_000) : null;
+
+    const items = rows.map((row) => {
+      const arrivedAt = row.booking?.arrivedAt ?? null;
+      return {
+        id: row.id,
+        reference: row.booking?.reference ?? null,
+        customerName: row.booking?.company?.name ?? null,
+        status: row.status,
+        schedulingStatus: row.booking?.schedulingStatus ?? null,
+        /** Dispatch (cargo loaded) to the train arriving. */
+        transitMinutes: minutes(row.booking?.loadedAt, arrivedAt),
+        /** Arrival to the agent picking the work up. */
+        pickupMinutes: minutes(arrivedAt, row.startedAt),
+        /** Arrival to the work being finished — the headline metric. */
+        clearanceMinutes: minutes(arrivedAt, row.finishedAt),
+        documentCount: (docCounts.get(row.id) ?? []).length,
+      };
+    });
+
+    const median = (values: number[]): number | null => {
+      if (!values.length) return null;
+      const sorted = [...values].sort((a, b) => a - b);
+      const mid = Math.floor(sorted.length / 2);
+      return sorted.length % 2
+        ? sorted[mid]
+        : Math.round((sorted[mid - 1] + sorted[mid]) / 2);
+    };
+
+    const cleared = items
+      .map((i) => i.clearanceMinutes)
+      .filter((v): v is number => v !== null);
+    const pickups = items
+      .map((i) => i.pickupMinutes)
+      .filter((v): v is number => v !== null);
+
+    // SLA bands, in minutes: inside 2h, inside 6h, beyond.
+    const sla = {
+      under2h: cleared.filter((v) => v <= 120).length,
+      under6h: cleared.filter((v) => v > 120 && v <= 360).length,
+      over6h: cleared.filter((v) => v > 360).length,
+    };
+
+    // Coverage counts only bookings that COULD have documents — uploads are
+    // gated on dispatch, so counting scheduled ones would invent a failure.
+    const dispatched = items.filter((i) => i.schedulingStatus === "DISPATCHED");
+    const withDocs = dispatched.filter((i) => i.documentCount > 0).length;
+
+    return {
+      totals: {
+        assignments: items.length,
+        open: items.filter((i) => i.status !== TransitAssignmentStatus.Finished)
+          .length,
+        finished: items.filter(
+          (i) => i.status === TransitAssignmentStatus.Finished,
+        ).length,
+        readyForDocuments: items.filter(
+          (i) =>
+            i.schedulingStatus === "DISPATCHED" &&
+            i.status !== TransitAssignmentStatus.Finished,
+        ).length,
+        documents: items.reduce((sum, i) => sum + i.documentCount, 0),
+      },
+      performance: {
+        medianClearanceMinutes: median(cleared),
+        medianPickupMinutes: median(pickups),
+        fastestClearanceMinutes: cleared.length ? Math.min(...cleared) : null,
+        slowestClearanceMinutes: cleared.length ? Math.max(...cleared) : null,
+        onTimeRate: cleared.length
+          ? Math.round(((sla.under2h + sla.under6h) / cleared.length) * 100)
+          : null,
+        measured: cleared.length,
+      },
+      sla,
+      coverage: {
+        dispatched: dispatched.length,
+        withDocuments: withDocs,
+      },
+      /** Newest first, for the timeline and the recent-activity list. */
+      items: items.slice(0, 12),
+    };
+  }
+
+  async findMine(userId: string, query: MyAssignmentsQueryDto = {}) {
+    const agent = await this.requireAgentForUser(userId);
+    const page = query.page ?? 1;
+    const pageSize = query.pageSize ?? 20;
+
+    const [rows, total] =
+      await this.assignmentsRepository.findByTransitAgentPaginated(
+        agent.id,
+        {
+          status: query.status,
+          schedulingStatus: query.schedulingStatus,
+          search: query.search,
+        },
+        (page - 1) * pageSize,
+        pageSize,
+      );
+
+    // Documents come back with the list so the grid can show a per-row count.
+    // Batched deliberately: one lookup for the page, not one per assignment.
+    const grouped = rows.length
+      ? await this.filesService.findByResourceIdsGrouped(
+          rows.map((row) => row.id),
+          TRANSIT_ASSIGNMENT_FILE_RESOURCE,
+        )
+      : new Map();
+
+    return {
+      items: rows.map((row) => ({
+        ...this.toView(row),
+        files: (grouped.get(row.id) ?? []).map((record: FileRecord) => ({
+          id: record.id,
+          name: record.name,
+          title: record.title,
+          url: record.url,
+          size: record.size,
+          mimeType: record.mimeType,
+          uploadedAt: record.createdAt.toISOString(),
+          updatedAt: record.updatedAt.toISOString(),
+          uploadedByUserId: record.uploadedByUserId,
+          uploadedByName: record.uploadedByName,
+        })),
+      })),
+      meta: {
+        total,
+        page,
+        pageSize,
+        totalPages: Math.max(1, Math.ceil(total / pageSize)),
+      },
+    };
+  }
+
+  /**
+   * One of the signed-in agent's own assignments, with its documents.
+   * Ownership is asserted rather than filtered: a mismatch is hidden behind a
+   * NotFound so assignment ids cannot be probed.
+   */
+  async findMineById(
+    userId: string,
+    id: string,
+  ): Promise<TransitAssignmentView> {
+    const agent = await this.requireAgentForUser(userId);
+    const assignment =
+      await this.assignmentsRepository.findOneWithRelations(id);
+    if (!assignment || assignment.transitAgentId !== agent.id) {
+      throw new NotFoundException(`Transit assignment ${id} not found`);
+    }
+    return { ...this.toView(assignment), files: await this.listFiles(id) };
+  }
+
+  /** Assert the assignment is this user's before any write reaches it. */
+  private async assertMine(userId: string, id: string): Promise<void> {
+    await this.findMineById(userId, id);
+  }
+
+  async uploadMyFiles(
+    userId: string,
+    id: string,
+    files: Express.Multer.File[],
+    uploader: { userId?: string; name?: string },
+    titles?: string[],
+  ): Promise<TransitAssignmentFileView[]> {
+    await this.assertMine(userId, id);
+    return this.uploadFiles(id, files, uploader, titles);
+  }
+
+  async removeMyFile(
+    userId: string,
+    id: string,
+    fileId: string,
+  ): Promise<void> {
+    await this.assertMine(userId, id);
+    return this.removeFile(id, fileId);
+  }
+
+  /**
+   * The portal's Save / Finish action.
+   *
+   * Save keeps the assignment open (moving it to IN_PROGRESS so the work reads
+   * as under way); Finish closes it, which also locks its documents — see
+   * `assertUploadAllowed`.
+   */
+  async submitMine(
+    userId: string,
+    id: string,
+    input: { finish: boolean; note?: string },
+  ): Promise<TransitAssignmentView> {
+    const current = await this.findMineById(userId, id);
+    if (current.status === TransitAssignmentStatus.Finished) {
+      throw new ForbiddenException("This assignment is already finished.");
+    }
+    await this.update(id, {
+      status: input.finish
+        ? TransitAssignmentStatus.Finished
+        : TransitAssignmentStatus.InProgress,
+      note: input.note,
+    });
+    return this.findMineById(userId, id);
+  }
+
+  async create(
+    dto: CreateTransitAssignmentDto,
+    assignedByUserId?: string,
+  ): Promise<TransitAssignmentView> {
+    const booking = await this.bookingsRepository.findOne({
+      where: { id: dto.bookingId },
+      select: { id: true },
+    });
+    if (!booking) {
+      throw new NotFoundException(`Booking ${dto.bookingId} not found`);
+    }
+    const agent = await this.transitAgentsRepository.findById(
+      dto.transitAgentId,
+    );
+    if (!agent) {
+      throw new NotFoundException(
+        `Transit agent ${dto.transitAgentId} not found`,
+      );
+    }
+    if (
+      await this.assignmentsRepository.existsForPair(
+        dto.bookingId,
+        dto.transitAgentId,
+      )
+    ) {
+      throw new ConflictException(
+        `${agent.name} is already assigned to this booking`,
+      );
+    }
+
+    const status = dto.status ?? TransitAssignmentStatus.NotStarted;
+    const created = await this.assignmentsRepository.create({
+      bookingId: dto.bookingId,
+      transitAgentId: dto.transitAgentId,
+      status,
+      // Creating straight into a working state still has to stamp its clock, or
+      // the assignment would report no start.
+      startedAt:
+        status === TransitAssignmentStatus.NotStarted ? null : new Date(),
+      finishedAt:
+        status === TransitAssignmentStatus.Finished ? new Date() : null,
+      assignedByUserId: assignedByUserId ?? null,
+      note: dto.note?.trim() || null,
+    });
+
+    return this.findById(created.id);
+  }
+
+  async update(
+    id: string,
+    dto: UpdateTransitAssignmentDto,
+  ): Promise<TransitAssignmentView> {
+    const current = await this.assignmentsRepository.findOneWithRelations(id);
+    if (!current) {
+      throw new NotFoundException(`Transit assignment ${id} not found`);
+    }
+
+    const patch: Partial<TransitAssignment> = {};
+    if (dto.note !== undefined) patch.note = dto.note.trim() || null;
+
+    if (dto.status && dto.status !== current.status) {
+      patch.status = dto.status;
+      if (dto.status === TransitAssignmentStatus.InProgress) {
+        // Only the FIRST start is recorded — reopening finished work keeps the
+        // original start, so the elapsed time still spans the whole job.
+        patch.startedAt = current.startedAt ?? new Date();
+        patch.finishedAt = null;
+      } else if (dto.status === TransitAssignmentStatus.Finished) {
+        patch.startedAt = current.startedAt ?? new Date();
+        patch.finishedAt = new Date();
+      } else {
+        // Back to NOT_STARTED — the work is being reset, so both clocks clear
+        // rather than leaving a duration for work that no longer happened.
+        patch.startedAt = null;
+        patch.finishedAt = null;
+      }
+    }
+
+    const updated = await this.assignmentsRepository.update(id, patch);
+    if (!updated) {
+      throw new NotFoundException(`Transit assignment ${id} not found`);
+    }
+    return this.findById(id);
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.findById(id);
+    await this.assignmentsRepository.softDelete(id);
+  }
+
+  // ── Documents ─────────────────────────────────────────────────────────────
+  // Stored in `freight.files` under TRANSIT_ASSIGNMENT_FILE_RESOURCE rather
+  // than a table of their own: that one already carries the MinIO object, the
+  // upload time, the uploader and the supersede history.
+
+  /**
+   * Whether an assignment may still receive documents.
+   *
+   * Two gates, both business rules rather than UI conveniences:
+   *  - the booking must actually be on its way (`DISPATCHED`), since there is
+   *    nothing to clear before the train leaves;
+   *  - the assignment must not be FINISHED — filing closes with the work, so a
+   *    finished record cannot grow new paperwork afterwards.
+   */
+  private assertUploadAllowed(assignment: TransitAssignment): void {
+    if (assignment.status === TransitAssignmentStatus.Finished) {
+      throw new ForbiddenException(
+        "This assignment is finished — its documents can no longer be changed.",
+      );
+    }
+    if (assignment.booking?.schedulingStatus !== "DISPATCHED") {
+      throw new ForbiddenException(
+        "Documents can only be uploaded once the booking has been dispatched.",
+      );
+    }
+  }
+
+  async listFiles(id: string): Promise<TransitAssignmentFileView[]> {
+    const records = await this.filesService.findByResource(
+      id,
+      TRANSIT_ASSIGNMENT_FILE_RESOURCE,
+    );
+    return records.map((record) => ({
+      id: record.id,
+      name: record.name,
+      title: record.title,
+      url: record.url,
+      size: record.size,
+      mimeType: record.mimeType,
+      uploadedAt: record.createdAt.toISOString(),
+      updatedAt: record.updatedAt.toISOString(),
+      uploadedByUserId: record.uploadedByUserId,
+      uploadedByName: record.uploadedByName,
+    }));
+  }
+
+  async uploadFiles(
+    id: string,
+    files: Express.Multer.File[],
+    uploader: { userId?: string; name?: string },
+    /**
+     * A display name per file, positionally matched to `files`. Multer preserves
+     * the multipart part order, and the client appends one `titles` entry per
+     * file in the same order, so index N names file N. A missing or blank entry
+     * falls back to the original filename.
+     */
+    titles?: string[],
+  ): Promise<TransitAssignmentFileView[]> {
+    if (!files?.length) {
+      throw new BadRequestException("No files were uploaded");
+    }
+    // Asserts the assignment exists before anything reaches MinIO — an upload
+    // keyed to a missing row would be unreachable storage nobody ever lists.
+    const assignment =
+      await this.assignmentsRepository.findOneWithRelations(id);
+    if (!assignment) {
+      throw new NotFoundException(`Transit assignment ${id} not found`);
+    }
+    this.assertUploadAllowed(assignment);
+
+    await Promise.all(
+      files.map((file, index) =>
+        this.filesService.upload({
+          resourceId: id,
+          resource: TRANSIT_ASSIGNMENT_FILE_RESOURCE,
+          code: file.fieldname || "document",
+          file,
+          title: titles?.[index]?.trim() || null,
+          uploadedByUserId: uploader.userId ?? null,
+          uploadedByName: uploader.name ?? null,
+        }),
+      ),
+    );
+
+    return this.listFiles(id);
+  }
+
+  async removeFile(id: string, fileId: string): Promise<void> {
+    const assignment =
+      await this.assignmentsRepository.findOneWithRelations(id);
+    if (!assignment) {
+      throw new NotFoundException(`Transit assignment ${id} not found`);
+    }
+    // Same gate as upload: a finished assignment's paperwork is fixed, and
+    // removal is as much a change as adding.
+    this.assertUploadAllowed(assignment);
+
+    const files = await this.filesService.findByResource(
+      id,
+      TRANSIT_ASSIGNMENT_FILE_RESOURCE,
+    );
+    // Scoped to this assignment's own documents: a bare file id would let one
+    // assignment delete another's paperwork.
+    if (!files.some((file) => file.id === fileId)) {
+      throw new NotFoundException(
+        `File ${fileId} not found on this assignment`,
+      );
+    }
+    await this.filesService.remove(fileId);
+  }
+}
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..43e7d7ae8 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,
@@ -1503,6 +1509,7 @@ export class WarehouseInventoryService {
         grnNumber: string;
         direction?: string | null;
         warehouseId?: string | null;
+        bookingId?: string | null;
       };
       booking: {
         companyId?: string | null;
@@ -1724,6 +1731,7 @@ export class WarehouseInventoryService {
             grnNumber,
             direction: dto.direction,
             warehouseId: dto.warehouseId,
+            bookingId,
           },
           booking,
           bookingId,
@@ -2863,6 +2871,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);
@@ -2971,6 +3109,7 @@ export class WarehouseInventoryService {
         grnNumber,
         direction: bookingDirection,
         warehouseId: dto.warehouseId,
+        bookingId: dto.bookingId ?? null,
       });
 
       return saved.id;
@@ -2996,12 +3135,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 +3175,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 +3199,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 +3221,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 +3449,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 +3467,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 +6373,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 };
   }
 
@@ -6261,10 +6617,9 @@ export class WarehouseInventoryService {
     grnNumber: string;
     direction?: string | null;
     warehouseId?: string | null;
+    /** Resolves the company, which unlocks in-app + email alongside the SMS. */
+    bookingId?: string | null;
   }): Promise<void> {
-    const phone = params.phone?.trim();
-    if (!phone) return;
-
     const ownerName = params.ownerName?.trim() || 'Customer';
     const bookingReference = params.bookingReference?.trim();
     const message =
@@ -6274,6 +6629,47 @@ export class WarehouseInventoryService {
       (params.direction ? `Direction: ${params.direction}. ` : '') +
       `Thank you.`;
 
+    // A booking gives us the company, and with it the customer's inbox and
+    // email — not just whatever phone number the gate clerk typed. Without one
+    // (manual or backlog receive) the typed phone is all there is, so the
+    // original SMS-only path stands.
+    let companyId: string | null = null;
+    if (params.bookingId) {
+      try {
+        const [row]: Array<{ companyId: string | null }> = await this.dataSource.query(
+          `SELECT company_id AS "companyId"
+             FROM freight.bookings
+            WHERE id = $1 AND deleted_at IS NULL`,
+          [params.bookingId],
+        );
+        companyId = row?.companyId ?? null;
+      } catch (error) {
+        this.logger.warn(`GRN ${params.grnNumber}: company lookup failed: ${String(error)}`);
+      }
+    }
+
+    if (companyId) {
+      try {
+        await this.inbox.notify({
+          recipients: { companyId },
+          audience: NotificationAudience.PORTAL,
+          type: NotificationType.DOCUMENT_ACTION,
+          title: 'Cargo received — GRN issued',
+          body: message,
+          link: params.bookingId ? `/bookings/${params.bookingId}` : undefined,
+          data: { grnNumber: params.grnNumber, bookingId: params.bookingId ?? null },
+        });
+        // Sends SMS *and* email to the company's own contacts, so the typed
+        // phone below is skipped to avoid texting the customer twice.
+        await sendCompanyChannels(this.dataSource, this.notifications, companyId, message);
+        return;
+      } catch (error) {
+        this.logger.error(`Failed to notify company for GRN ${params.grnNumber}: ${String(error)}`);
+      }
+    }
+
+    const phone = params.phone?.trim();
+    if (!phone) return;
     try {
       await this.notifications.directSend('sms', phone, message);
     } catch (error) {
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..2a8ac578e 100644
--- a/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
+++ b/apps/edr-freight-api/src/seed/freight-permissions.registry.ts
@@ -465,6 +465,13 @@ export const CONTRACT_PERMISSIONS: FreightPermissionSeed[] = [
     "edr_freight_app:contracts:suspend",
     "Suspend / resume a signed contract",
   ),
+  // Terminal kill switch. Unlike suspend this cannot be undone — the customer
+  // re-submits a fresh contract with the same parameters instead.
+  perm(
+    "a3000001-0001-4000-8000-00000000001c",
+    "edr_freight_app:contracts:cancel",
+    "Cancel a contract (terminal)",
+  ),
 ];
 
 // Historical ids. EdrOrgSeeder no longer sends them — it upserts on `key` and
@@ -652,6 +659,32 @@ export const SHIPPING_LINE_PERMISSIONS: FreightPermissionSeed[] = [
   ),
 ];
 
+// C3. Transit assignments — a transit agent's work on one booking: status,
+// timings and documents. Separate from the booking's transit-assignee handshake,
+// which only decides who will handle customs.
+export const TRANSIT_ASSIGNMENT_PERMISSIONS: FreightPermissionSeed[] = [
+  perm(
+    "d1a00003-0001-4000-8000-000000000001",
+    "edr_freight_app:transit_assignments:view",
+    "View transit assignments",
+  ),
+  perm(
+    "d1a00003-0001-4000-8000-000000000002",
+    "edr_freight_app:transit_assignments:create",
+    "Assign a transit agent to a booking",
+  ),
+  perm(
+    "d1a00003-0001-4000-8000-000000000003",
+    "edr_freight_app:transit_assignments:update",
+    "Update a transit assignment and its documents",
+  ),
+  perm(
+    "d1a00003-0001-4000-8000-000000000004",
+    "edr_freight_app:transit_assignments:delete",
+    "Remove a transit assignment",
+  ),
+];
+
 // Internal chat (Matrix/Element) — sidebar visibility + manual reconcile trigger.
 export const CHAT_PERMISSIONS: FreightPermissionSeed[] = [
   perm(
@@ -1272,6 +1305,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",
@@ -1878,6 +1916,11 @@ export const NOTIFICATION_PERMISSIONS: FreightPermissionSeed[] = [
     "edr_freight_app:additional_charges:get_notification",
     "Receive additional charge notifications",
   ),
+  perm(
+    "f3a00001-0001-4000-8000-00000000000a",
+    "edr_freight_app:warehouse_inventory:get_notification",
+    "Receive warehouse desk notifications (containers left behind at loading)",
+  ),
 ];
 
 export const ADVANCED_BACKOFFICE_PERMISSIONS: FreightPermissionSeed[] = [
@@ -1885,6 +1928,7 @@ export const ADVANCED_BACKOFFICE_PERMISSIONS: FreightPermissionSeed[] = [
   ...OVERVIEW_LAYOUT_PERMISSIONS,
   ...CUSTOMER_PERMISSIONS,
   ...SHIPPING_LINE_PERMISSIONS,
+  ...TRANSIT_ASSIGNMENT_PERMISSIONS,
   ...CHAT_PERMISSIONS,
   ...FINANCE_PERMISSIONS,
   ...MILE_PERMISSIONS,
@@ -2029,6 +2073,7 @@ export const FREIGHT_PERMS = {
     clearanceDjActions: "edr_freight_app:contracts:clearance_dj_actions",
     clearanceDutyAdvise: "edr_freight_app:contracts:clearance_duty_advise",
     suspend: "edr_freight_app:contracts:suspend",
+    cancel: "edr_freight_app:contracts:cancel",
     editDocument: "edr_freight_app:contracts:edit_document",
     finalInvoiceRaise: "edr_freight_app:contracts:final_invoice_raise",
     finalInvoiceConfirm: "edr_freight_app:contracts:final_invoice_confirm",
@@ -2113,6 +2158,12 @@ export const FREIGHT_PERMS = {
     // Notification selector, not a route guard — see NOTIFICATION_PERMISSIONS.
     getNotification: "edr_freight_app:customers:get_notification",
   },
+  transitAssignments: {
+    view: "edr_freight_app:transit_assignments:view",
+    create: "edr_freight_app:transit_assignments:create",
+    update: "edr_freight_app:transit_assignments:update",
+    delete: "edr_freight_app:transit_assignments:delete",
+  },
   shippingLines: {
     view: "edr_freight_app:shipping_lines:view",
     create: "edr_freight_app:shipping_lines:create",
@@ -2307,6 +2358,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",
@@ -2336,6 +2388,12 @@ export const FREIGHT_PERMS = {
     release: "edr_freight_app:warehouse_inventory:release",
     deliver: "edr_freight_app:warehouse_inventory:deliver",
     inspect: "edr_freight_app:warehouse_inventory:inspect",
+    /**
+     * Notification selector, not a route guard — who gets pinged when cargo is
+     * left behind at loading and needs warehouse space. Assign it to whichever
+     * desk owns that; it grants access to nothing.
+     */
+    getNotification: "edr_freight_app:warehouse_inventory:get_notification",
   },
   interchangeDocuments: {
     view: "edr_freight_app:interchange_documents:view",
@@ -2826,6 +2884,9 @@ export const ROLE_PERMISSION_PRESETS = {
     FREIGHT_PERMS.contracts.generateContract,
     ...bothFreightTypes(FREIGHT_PERMS.contracts.signStaff),
     FREIGHT_PERMS.contracts.suspend,
+    // Terminal kill switch, granted alongside suspend on the same desk that
+    // already rejects contracts and cancels bookings.
+    FREIGHT_PERMS.contracts.cancel,
     FREIGHT_PERMS.contracts.editDocument,
     ...BOOKING_DESK_NOTIFICATION_KEYS,
     // Marketing follows up with the customer when a reviewer sends profile
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/package.json b/apps/edr-freight-web/backoffice/package.json
index e0ef813e9..7674f924c 100644
--- a/apps/edr-freight-web/backoffice/package.json
+++ b/apps/edr-freight-web/backoffice/package.json
@@ -97,6 +97,7 @@
     "react-markdown": "^9.1.0",
     "react-pdf": "^10.4.1",
     "react-pdf-html": "^2.1.5",
+    "react-phone-number-input": "^3.4.17",
     "react-quill-new": "^3.8.3",
     "react-resizable-panels": "^3.0.6",
     "react-router-dom": "^6.27.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/PhoneField.test.ts b/apps/edr-freight-web/backoffice/src/components/PhoneField.test.ts
new file mode 100644
index 000000000..b6576f946
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/PhoneField.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+
+import { isSmsReachable, isValidPhone } from "./PhoneField";
+
+/**
+ * `isSmsReachable` mirrors `isDomesticPhone` in the API's otp.service. The two
+ * must agree: this one greys out the SMS option, that one decides whether the
+ * message is actually sent, and a disagreement means the UI promises a text
+ * nobody sends (or hides one that would have worked). These cases are the same
+ * ones the API spec asserts.
+ */
+describe("isSmsReachable", () => {
+  it.each(["+251986680099", "0986680099", "251986680099"])(
+    "accepts Ethiopian mobile form %s",
+    (phone) => expect(isSmsReachable(phone)).toBe(true),
+  );
+
+  it.each(["+25377123456", "25377123456", "77123456"])(
+    "accepts Djibouti mobile form %s",
+    (phone) => expect(isSmsReachable(phone)).toBe(true),
+  );
+
+  it.each([
+    "+14155550123",
+    "+447911123456",
+    "0712345678",
+    "+2519866",
+    "12345",
+    // Djibouti fixed line — valid number, not a mobile the gateway serves.
+    "+25321350000",
+    "+25366123456",
+  ])("rejects unreachable or malformed %s", (phone) =>
+    expect(isSmsReachable(phone)).toBe(false),
+  );
+
+  it.each([undefined, null, ""])("treats %s as unreachable", (phone) =>
+    expect(isSmsReachable(phone)).toBe(false),
+  );
+});
+
+/**
+ * The country-picker input emits a PARTIAL E.164 while the user is still
+ * typing — "+25377" is a non-empty string that will post happily and come back
+ * as a 400 from the API's own IsValidPhone. Forms must treat "non-empty" and
+ * "complete" as different questions, so this is the check they call.
+ */
+describe("isValidPhone", () => {
+  it.each(["+25377834567", "+251911223344"])(
+    "accepts the complete number %s",
+    (phone) => expect(isValidPhone(phone)).toBe(true),
+  );
+
+  it.each(["+253", "+25377", "+2537712", "+251", "+2519112"])(
+    "rejects the partial number %s the picker emits mid-typing",
+    (phone) => expect(isValidPhone(phone)).toBe(false),
+  );
+
+  it.each([undefined, null, ""])("treats %s as invalid", (phone) =>
+    expect(isValidPhone(phone)).toBe(false),
+  );
+});
diff --git a/apps/edr-freight-web/backoffice/src/components/PhoneField.tsx b/apps/edr-freight-web/backoffice/src/components/PhoneField.tsx
new file mode 100644
index 000000000..8714ccd8d
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/PhoneField.tsx
@@ -0,0 +1,107 @@
+import { Input, TextInput } from "@mantine/core";
+import RPNInput, { isValidPhoneNumber } from "react-phone-number-input";
+import "react-phone-number-input/style.css";
+import "./phone-field.css";
+
+/**
+ * The countries the railway operates between, and the only two the SMS gateway
+ * is contracted to reach (see `REACHABLE_MOBILE_PATTERNS` in the API's
+ * otp.service). Restricting the picker to them keeps staff from entering a
+ * number that would validate but could never receive an activation link.
+ */
+export const SUPPORTED_PHONE_COUNTRIES = ["DJ", "ET"] as const;
+
+/**
+ * Djibouti — most accounts entered here (transit agents above all) are
+ * Djibouti-side, so it saves the picker interaction on the common case.
+ */
+export const DEFAULT_PHONE_COUNTRY = "DJ";
+
+/**
+ * Re-exported so callers can validate before submitting.
+ *
+ * Needed because the input emits a PARTIAL E.164 while the user is still
+ * typing — "+25377" and "+2537712" are non-empty strings that reach a payload
+ * happily and then come back as a 400 from the API's own `IsValidPhone`. A
+ * caller must treat "non-empty" and "complete" as different questions.
+ */
+export const isValidPhone = (value?: string | null): boolean =>
+  !!value && isValidPhoneNumber(value);
+
+/**
+ * Whether the SMS gateway can actually reach this number.
+ *
+ * Mirrors `isDomesticPhone` in the API's otp.service — Ethiopian `+2519…` and
+ * Djiboutian `+25377…` mobiles. Anything else (a landline, another country) is
+ * queued and silently lost, so the UI offers email instead of promising an SMS.
+ */
+export function isSmsReachable(rawPhone?: string | null): boolean {
+  if (!rawPhone) return false;
+  const digits = rawPhone.trim().replace(/[^\d+]/g, "");
+  const bare = digits.replace(/^\+/, "").replace(/^0+/, "");
+  const normalized = digits.startsWith("+")
+    ? digits
+    : /^251\d{9}$|^253\d{8}$/.test(digits)
+      ? `+${digits}`
+      : /^9\d{8}$|^7\d{8}$/.test(bare)
+        ? `+251${bare}`
+        : /^77\d{6}$/.test(bare)
+          ? `+253${bare}`
+          : digits;
+  return /^\+2519\d{8}$/.test(normalized) || /^\+25377\d{6}$/.test(normalized);
+}
+
+export interface PhoneFieldProps {
+  label?: string;
+  value?: string;
+  onChange: (value: string | undefined) => void;
+  error?: string;
+  required?: boolean;
+  disabled?: boolean;
+  placeholder?: string;
+  description?: string;
+}
+
+/**
+ * Phone input with a country selector, limited to Ethiopia and Djibouti.
+ * Emits a single E.164 value (e.g. +251912345678, +25377123456) so the API
+ * never has to guess a country from a bare local number.
+ */
+export function PhoneField({
+  label,
+  value,
+  onChange,
+  error,
+  required,
+  disabled,
+  placeholder = "77 83 45 67",
+  description,
+}: PhoneFieldProps) {
+  return (
+    <Input.Wrapper
+      label={label}
+      required={required}
+      error={error}
+      description={description}
+      styles={{ label: { fontWeight: 600, fontSize: 14, color: "#10202F" } }}
+    >
+      <div
+        className={`edr-phone-wrapper${error ? " edr-phone-wrapper--error" : ""}`}
+      >
+        <RPNInput
+          international
+          defaultCountry={DEFAULT_PHONE_COUNTRY}
+          countries={[...SUPPORTED_PHONE_COUNTRIES]}
+          countryCallingCodeEditable={false}
+          value={value}
+          onChange={onChange}
+          inputComponent={TextInput}
+          disabled={disabled}
+          placeholder={placeholder}
+        />
+      </div>
+    </Input.Wrapper>
+  );
+}
+
+export default PhoneField;
diff --git a/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingCargoCard.tsx b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingCargoCard.tsx
index dc7286b5c..f2d6c07d4 100644
--- a/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingCargoCard.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/bookings/detail/BookingCargoCard.tsx
@@ -30,6 +30,13 @@ export function BookingCargoCard({ booking }: BookingCargoCardProps) {
   );
 
   const isBulk = booking.freightType === "BULK";
+  // NUMBER_OF_WAGONS cargo is booked by a wagon COUNT, not by tonnage — the
+  // count the customer fixed is what allocation and per-wagon pricing use, so
+  // it belongs on the card next to the weight.
+  const requestedWagons =
+    isBulk && booking.cargoType?.unitOfMeasure === "NUMBER_OF_WAGONS"
+      ? Number(booking.bulkRequestedWagons ?? 0) || null
+      : null;
   // Bulk: the commodity itself (Wheat, Steel…) is the headline. Containers:
   // the freight kind, with the shipper's own description alongside.
   const cargoHeadline = isBulk
@@ -46,6 +53,11 @@ export function BookingCargoCard({ booking }: BookingCargoCardProps) {
         <Badge variant="light" color={isBulk ? "orange" : "blue"} radius="sm">
           {isBulk ? "Bulk" : "Container"}
         </Badge>
+        {requestedWagons != null ? (
+          <Badge variant="light" color="grape" radius="sm">
+            {requestedWagons} wagon{requestedWagons === 1 ? "" : "s"}
+          </Badge>
+        ) : null}
         {cargoDescription ? (
           <Text size="sm" c="dimmed">
             — {cargoDescription}
@@ -62,6 +74,9 @@ export function BookingCargoCard({ booking }: BookingCargoCardProps) {
           }
         />
         <MetricTile label="Total VGM" value={`${tons} tons`} />
+        {requestedWagons != null && (
+          <MetricTile label="Wagons booked" value={`${requestedWagons}`} />
+        )}
         {items != null && <MetricTile label="Items" value={`${items}`} />}
         <MetricTile
           label="Hazardous"
diff --git a/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx b/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx
index d2a245f24..be70ffe4d 100644
--- a/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/contracts/ContractActionsToolbar.tsx
@@ -3,6 +3,7 @@ import { useNavigate } from "react-router-dom";
 import { useQuery } from "@tanstack/react-query";
 import { Button, Group, Modal, Stack, Text, Textarea } from "@mantine/core";
 import {
+  Ban,
   Check,
   Eye,
   // FilePen, // ponytail: back with the "Edit contract articles" button
@@ -81,6 +82,8 @@ export function ContractActionsToolbar({
   const mayReject = hasPermission(user, FREIGHT_PERMS.contracts.reject[arm]);
   // One key both ways — whoever can freeze a contract can unfreeze it.
   const maySuspend = hasPermission(user, FREIGHT_PERMS.contracts.suspend);
+  // Cancel is its own key — it is terminal, so it is NOT implied by suspend.
+  const mayCancel = hasPermission(user, FREIGHT_PERMS.contracts.cancel);
 
   const [editorOpen, setEditorOpen] = useState(false);
   const [editorMode, setEditorMode] = useState<"accept" | "edit">("accept");
@@ -93,6 +96,67 @@ export function ContractActionsToolbar({
   const [suspendReason, setSuspendReason] = useState("");
   const [resumeOpen, setResumeOpen] = useState(false);
   const [resumeNote, setResumeNote] = useState("");
+  const [cancelOpen, setCancelOpen] = useState(false);
+  const [cancelReason, setCancelReason] = useState("");
+
+  // Shared by the suspended branch and the normal toolbar — both can cancel.
+  const cancelModal = (
+    <Modal
+      opened={cancelOpen}
+      onClose={() => setCancelOpen(false)}
+      title="Cancel this contract?"
+      centered
+    >
+      <Stack gap="md">
+        <Text size="sm">
+          Contract <b>{contract.reference}</b> will be cancelled permanently.
+          This cannot be undone — there is no way to reactivate it. A new
+          contract with the same details can be submitted afterwards. The
+          customer is notified.
+        </Text>
+        <Textarea
+          label="Reason for cancellation"
+          placeholder="Explain why this contract is being cancelled…"
+          autosize
+          minRows={3}
+          value={cancelReason}
+          onChange={(e) => setCancelReason(e.currentTarget.value)}
+        />
+        <Group justify="flex-end" gap="sm">
+          <Button variant="default" onClick={() => setCancelOpen(false)}>
+            Keep contract
+          </Button>
+          <Button
+            color="red"
+            disabled={!cancelReason.trim()}
+            loading={mutations.cancelByStaff.isPending}
+            onClick={() =>
+              mutations.cancelByStaff.mutate(cancelReason, {
+                onSuccess: () => {
+                  setCancelOpen(false);
+                  setCancelReason("");
+                },
+              })
+            }
+          >
+            Cancel contract
+          </Button>
+        </Group>
+      </Stack>
+    </Modal>
+  );
+
+  const cancelButton = mayCancel ? (
+    <Button
+      fullWidth
+      variant="light"
+      color="red"
+      leftSection={<Ban size={16} />}
+      onClick={() => setCancelOpen(true)}
+    >
+      Cancel contract
+    </Button>
+  ) : null;
 
   // Whether the document is editable depends on WHO is viewing — only the
   // approver whose turn it is may edit — so the server decides, not the client.
@@ -126,9 +190,13 @@ export function ContractActionsToolbar({
   if (status === "CHANGES_REQUESTED") {
     return (
       <SectionCard icon={Zap} title="Awaiting customer">
-        <Text size="sm" c="dimmed">
-          No staff actions until the customer resubmits the contract.
-        </Text>
+        <Stack gap="sm">
+          <Text size="sm" c="dimmed">
+            No staff actions until the customer resubmits the contract.
+          </Text>
+          {cancelButton}
+        </Stack>
+        {cancelModal}
       </SectionCard>
     );
   }
@@ -166,6 +234,7 @@ export function ContractActionsToolbar({
               You do not have permission to lift a suspension.
             </Text>
           )}
+          {cancelButton}
         </Stack>
 
         <Modal
@@ -209,6 +278,8 @@ export function ContractActionsToolbar({
             </Group>
           </Stack>
         </Modal>
+
+        {cancelModal}
       </SectionCard>
     );
   }
@@ -362,11 +433,16 @@ export function ContractActionsToolbar({
           </Button>
         )}
 
+        {/* Available at every non-terminal status — the early returns above
+            already cover the statuses where cancelling makes no sense. */}
+        {cancelButton}
+
         {!canAccept &&
           !inApproval &&
           !canViewContract &&
           !canReviewClearance &&
-          !canSuspend && (
+          !canSuspend &&
+          !mayCancel && (
             <Text size="sm" c="dimmed">
               No staff actions available for this status. Monitor until the
               workflow advances.
@@ -515,6 +591,8 @@ export function ContractActionsToolbar({
           </Button>
         </Stack>
       </Modal>
+
+      {cancelModal}
     </SectionCard>
   );
 }
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/phone-field.css b/apps/edr-freight-web/backoffice/src/components/phone-field.css
new file mode 100644
index 000000000..3a0396ffd
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/phone-field.css
@@ -0,0 +1,82 @@
+/* Align react-phone-number-input with the portal's Mantine field styling:
+   44px height, 10px radius, edr border, brand-green focus ring. */
+
+.edr-phone-wrapper .PhoneInput {
+  display: flex;
+  align-items: stretch;
+  gap: 8px;
+}
+
+/* Country selector — a compact pill matching the input height/radius. */
+.edr-phone-wrapper .PhoneInputCountry {
+  margin: 0;
+  padding: 0 10px;
+  height: 2.25rem;
+  border: 0.0625rem  solid #b0bfce;
+  border-radius: 6px;
+  background: #fff;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  transition:
+    border-color 120ms ease,
+    box-shadow 120ms ease;
+}
+
+.edr-phone-wrapper .PhoneInputCountryIcon {
+  width: 22px;
+  height: 16px;
+  box-shadow: none;
+}
+
+.edr-phone-wrapper .PhoneInputCountrySelectArrow {
+  color: #6b7c8e;
+  opacity: 0.8;
+}
+
+/* The number input itself. */
+.edr-phone-input {
+  flex: 1;
+  min-width: 0;
+  height: 44px;
+  padding: 0 12px;
+  border: 1px solid #e6ecf2;
+  border-radius: 10px;
+  font-size: 14px;
+  color: #10202f;
+  background: #fff;
+  outline: none;
+  transition:
+    border-color 120ms ease,
+    box-shadow 120ms ease;
+}
+
+.edr-phone-input::placeholder {
+  color: #9aa8b5;
+}
+
+.edr-phone-input:focus {
+  border-color: #0ea371;
+  box-shadow: 0 0 0 3px rgba(14, 163, 113, 0.15);
+}
+
+.edr-phone-wrapper .PhoneInputCountry:focus-within {
+  border-color: #0ea371;
+  box-shadow: 0 0 0 3px rgba(14, 163, 113, 0.15);
+}
+
+.edr-phone-input:disabled,
+.edr-phone-wrapper .PhoneInputCountrySelect:disabled + .PhoneInputCountryIcon {
+  opacity: 0.6;
+  cursor: not-allowed;
+}
+
+/* Error state mirrors Mantine's invalid styling. */
+.edr-phone-wrapper--error .edr-phone-input,
+.edr-phone-wrapper--error .PhoneInputCountry {
+  border-color: #e03131;
+}
+
+.edr-phone-wrapper--error .edr-phone-input:focus {
+  box-shadow: 0 0 0 3px rgba(224, 49, 49, 0.12);
+}
diff --git a/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx b/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx
index e3bf11375..e3a3445c3 100644
--- a/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/ruleEngine/RuleEngineFormDialog.tsx
@@ -22,6 +22,7 @@ import {
   RULE_ENGINE_SELECT_NONE,
   type FormFieldDef,
 } from "@/pages/ruleEngine/config/resources";
+import PhoneField, { isValidPhone } from "@/components/PhoneField";
 import type { RuleEngineRecord } from "@/types/rule-engine";
 import { RULE_ENGINE_POSITION_END } from "./ruleEngineOrder.utils";
 
@@ -46,7 +47,11 @@ type FormRow =
 /** One editable distance tier of a tierList field (raw input strings). */
 type TierRow = { minKm: string; maxKm: string; rateValue: string };
 
-const emptyTier = (fromKm = ""): TierRow => ({ minKm: fromKm, maxKm: "", rateValue: "" });
+const emptyTier = (fromKm = ""): TierRow => ({
+  minKm: fromKm,
+  maxKm: "",
+  rateValue: "",
+});
 
 /**
  * Validate a tier set before submit: every tier complete, ranges sane, no
@@ -87,7 +92,11 @@ const buildFormRows = (fields: FormFieldDef[]): FormRow[] => {
   while (index < fields.length) {
     const field = fields[index];
 
-    if (field.type === "textarea" || field.type === "boolean" || field.type === "tierList") {
+    if (
+      field.type === "textarea" ||
+      field.type === "boolean" ||
+      field.type === "tierList"
+    ) {
       rows.push({ kind: "single", field });
       index += 1;
       continue;
@@ -113,9 +122,10 @@ const buildInitialValues = (
 ): Record<string, unknown> => {
   const values: Record<string, unknown> = {};
   for (const field of fields) {
-    const raw = field.getInitialValue && record
-      ? field.getInitialValue(record)
-      : record?.[field.name];
+    const raw =
+      field.getInitialValue && record
+        ? field.getInitialValue(record)
+        : record?.[field.name];
     if (field.type === "multiselect") {
       values[field.name] = Array.isArray(raw) ? raw.map(String) : [];
     } else if (field.type === "tierList") {
@@ -160,10 +170,13 @@ const resolveSelectValue = (
 };
 
 const inputStyles = {
-  label: { fontWeight: 600, marginBottom: 6, color: "var(--mantine-color-gray-8)" },
+  label: {
+    fontWeight: 600,
+    marginBottom: 6,
+    color: "var(--mantine-color-gray-8)",
+  },
 } as const;
 
-
 const RuleEngineFormDialog = ({
   open,
   onOpenChange,
@@ -195,13 +208,17 @@ const RuleEngineFormDialog = ({
       fields.filter((field) => {
         if (
           field.hideWhen &&
-          field.hideWhen.equals.includes(String(values[field.hideWhen.field] ?? ""))
+          field.hideWhen.equals.includes(
+            String(values[field.hideWhen.field] ?? ""),
+          )
         ) {
           return false;
         }
         if (
           field.showWhen &&
-          !field.showWhen.equals.includes(String(values[field.showWhen.field] ?? ""))
+          !field.showWhen.equals.includes(
+            String(values[field.showWhen.field] ?? ""),
+          )
         ) {
           return false;
         }
@@ -228,7 +245,10 @@ const RuleEngineFormDialog = ({
       // Changing what a rate applies to (or its surcharge trigger) can invalidate
       // the previously-chosen unit — reset it so the admin re-picks from the new
       // allowed set instead of submitting a stale, rejected unit.
-      if ((name === "appliesTo" || name === "trigger") && "rateUnit" in current) {
+      if (
+        (name === "appliesTo" || name === "trigger") &&
+        "rateUnit" in current
+      ) {
         next.rateUnit = "";
       }
       // The legal yards depend on what the rate is for and which way it runs, so
@@ -342,6 +362,20 @@ const RuleEngineFormDialog = ({
           [field.name]: `${field.label} is required.`,
         }));
         blocked = true;
+      } else if (field.type === "phone" && raw !== "" && raw !== undefined) {
+        // The country-picker input emits a PARTIAL E.164 while the user is
+        // still typing ("+25377"), which is non-empty and would post straight
+        // through to a 400 from the API's own validator. Reject it here, on the
+        // field, instead of as a server error the admin has to decode.
+        if (!isValidPhone(String(raw))) {
+          setFieldErrors((current) => ({
+            ...current,
+            [field.name]: `${field.label} is not a complete phone number.`,
+          }));
+          blocked = true;
+        } else {
+          payload[field.name] = raw;
+        }
       } else if (raw === "" || raw === undefined) {
         if (!field.required) continue;
         payload[field.name] = raw;
@@ -350,13 +384,19 @@ const RuleEngineFormDialog = ({
       }
     }
 
-    if (fields.some((f) => f.name === "code" && typeof payload.code === "string")) {
+    if (
+      fields.some((f) => f.name === "code" && typeof payload.code === "string")
+    ) {
       payload.code = String(payload.code).toUpperCase();
     }
 
     if (blocked) return;
 
-    if (!initialRecord && positionOptions && position !== RULE_ENGINE_POSITION_END) {
+    if (
+      !initialRecord &&
+      positionOptions &&
+      position !== RULE_ENGINE_POSITION_END
+    ) {
       payload.insertAfterId = position;
     }
 
@@ -421,7 +461,9 @@ const RuleEngineFormDialog = ({
       const setRows = (next: TierRow[]) => setField(field.name, next);
       const setRow = (index: number, key: keyof TierRow, value: string) => {
         if (value.trim().startsWith("-")) return;
-        setRows(rows.map((row, i) => (i === index ? { ...row, [key]: value } : row)));
+        setRows(
+          rows.map((row, i) => (i === index ? { ...row, [key]: value } : row)),
+        );
       };
       return (
         <Box key={field.name}>
@@ -443,7 +485,9 @@ const RuleEngineFormDialog = ({
                   step="any"
                   placeholder="0"
                   value={row.minKm}
-                  onChange={(e) => setRow(index, "minKm", e.currentTarget.value)}
+                  onChange={(e) =>
+                    setRow(index, "minKm", e.currentTarget.value)
+                  }
                   size="md"
                   radius="md"
                   styles={inputStyles}
@@ -456,7 +500,9 @@ const RuleEngineFormDialog = ({
                   step="any"
                   placeholder="No limit"
                   value={row.maxKm}
-                  onChange={(e) => setRow(index, "maxKm", e.currentTarget.value)}
+                  onChange={(e) =>
+                    setRow(index, "maxKm", e.currentTarget.value)
+                  }
                   size="md"
                   radius="md"
                   styles={inputStyles}
@@ -469,7 +515,9 @@ const RuleEngineFormDialog = ({
                   step="any"
                   placeholder="Rate per km"
                   value={row.rateValue}
-                  onChange={(e) => setRow(index, "rateValue", e.currentTarget.value)}
+                  onChange={(e) =>
+                    setRow(index, "rateValue", e.currentTarget.value)
+                  }
                   size="md"
                   radius="md"
                   styles={inputStyles}
@@ -494,7 +542,12 @@ const RuleEngineFormDialog = ({
                 size="xs"
                 leftSection={<Plus size={14} />}
                 // The next tier naturally starts where the previous one ends.
-                onClick={() => setRows([...rows, emptyTier(rows[rows.length - 1]?.maxKm ?? "")])}
+                onClick={() =>
+                  setRows([
+                    ...rows,
+                    emptyTier(rows[rows.length - 1]?.maxKm ?? ""),
+                  ])
+                }
               >
                 Add tier
               </Button>
@@ -531,7 +584,10 @@ const RuleEngineFormDialog = ({
           onChange={(v) => setField(field.name, v)}
           disabled={selectOptionsLoading}
           data={options
-            .filter((opt) => opt.value !== "" && opt.value !== RULE_ENGINE_SELECT_NONE)
+            .filter(
+              (opt) =>
+                opt.value !== "" && opt.value !== RULE_ENGINE_SELECT_NONE,
+            )
             .map((opt) => ({ label: opt.label, value: opt.value }))}
           searchable
           clearable
@@ -545,7 +601,9 @@ const RuleEngineFormDialog = ({
     if (field.type === "select") {
       // Dynamic options (e.g. rate unit) resolve from the live form values so
       // the choices track the other fields the admin has picked.
-      const options = field.optionsFromValues ? field.optionsFromValues(values) : (field.options ?? []);
+      const options = field.optionsFromValues
+        ? field.optionsFromValues(values)
+        : (field.options ?? []);
       // A derived select shows (and submits) its computed value and is locked,
       // matching the text-input branch — used by fields the shape decides on the
       // admin's behalf, e.g. a shipping-line rate's import-only direction.
@@ -558,14 +616,18 @@ const RuleEngineFormDialog = ({
           label={label}
           description={field.description}
           placeholder={
-            selectOptionsLoading ? "Loading options..." : (field.placeholder ?? "Select an option")
+            selectOptionsLoading
+              ? "Loading options..."
+              : (field.placeholder ?? "Select an option")
           }
           value={
             computedSelect !== undefined
               ? computedSelect
               : resolveSelectValue(field, values)
           }
-          onChange={(v) => setField(field.name, v === RULE_ENGINE_SELECT_NONE ? "" : v)}
+          onChange={(v) =>
+            setField(field.name, v === RULE_ENGINE_SELECT_NONE ? "" : v)
+          }
           disabled={
             selectOptionsLoading ||
             field.disabled ||
@@ -635,8 +697,29 @@ const RuleEngineFormDialog = ({
       );
     }
 
+    if (field.type === "phone") {
+      // Country-picker input restricted to Ethiopia and Djibouti — the two the
+      // SMS gateway reaches. Emits E.164, so the API never guesses a country
+      // from a bare local number.
+      return (
+        <PhoneField
+          key={field.name}
+          label={label}
+          description={field.description}
+          value={String(values[field.name] ?? "")}
+          onChange={(v) => setField(field.name, v ?? "")}
+          disabled={field.disabled || (field.disabledOnEdit && !!initialRecord)}
+          required={field.required}
+          error={fieldErrors[field.name] || undefined}
+          placeholder={field.placeholder}
+        />
+      );
+    }
+
     const isNumber = field.type === "number";
-    const computed = field.computeValue ? field.computeValue(values) : undefined;
+    const computed = field.computeValue
+      ? field.computeValue(values)
+      : undefined;
 
     return (
       <TextInput
@@ -654,8 +737,14 @@ const RuleEngineFormDialog = ({
         // numbers (@IsInt on points/sizes/order, @IsNumber on money, tons, km),
         // so let the field carry decimals and let a 400 catch the rest.
         step={isNumber ? "any" : undefined}
-        disabled={field.disabled || (field.disabledOnEdit && !!initialRecord) || computed !== undefined}
-        value={String((computed !== undefined ? computed : values[field.name]) ?? "")}
+        disabled={
+          field.disabled ||
+          (field.disabledOnEdit && !!initialRecord) ||
+          computed !== undefined
+        }
+        value={String(
+          (computed !== undefined ? computed : values[field.name]) ?? "",
+        )}
         onChange={(e) => {
           const next = e.currentTarget.value;
           if (isNumber && next.trim().startsWith("-")) return;
@@ -703,16 +792,27 @@ const RuleEngineFormDialog = ({
     >
       <form onSubmit={handleSubmit}>
         <Stack gap="lg">
-          <Box style={{ maxHeight: "calc(65vh - 120px)", overflowY: "auto", paddingRight: 4 }}>
+          <Box
+            style={{
+              maxHeight: "calc(65vh - 120px)",
+              overflowY: "auto",
+              paddingRight: 4,
+            }}
+          >
             <Stack gap="md">
               {!initialRecord && positionOptions ? (
                 <Select
                   label="Position"
                   description="New items are appended to the end by default."
                   value={position}
-                  onChange={(value) => setPosition(value ?? RULE_ENGINE_POSITION_END)}
+                  onChange={(value) =>
+                    setPosition(value ?? RULE_ENGINE_POSITION_END)
+                  }
                   data={[
-                    { label: "At end (default)", value: RULE_ENGINE_POSITION_END },
+                    {
+                      label: "At end (default)",
+                      value: RULE_ENGINE_POSITION_END,
+                    },
                     ...positionOptions,
                   ]}
                   searchable
@@ -724,9 +824,17 @@ const RuleEngineFormDialog = ({
               ) : null}
               {formRows.map((row) =>
                 row.kind === "pair" ? (
-                  <SimpleGrid key={`${row.fields[0].name}-${row.fields[1].name}`} cols={2} spacing="md">
-                    <Box style={{ minWidth: 0 }}>{renderField(row.fields[0])}</Box>
-                    <Box style={{ minWidth: 0 }}>{renderField(row.fields[1])}</Box>
+                  <SimpleGrid
+                    key={`${row.fields[0].name}-${row.fields[1].name}`}
+                    cols={2}
+                    spacing="md"
+                  >
+                    <Box style={{ minWidth: 0 }}>
+                      {renderField(row.fields[0])}
+                    </Box>
+                    <Box style={{ minWidth: 0 }}>
+                      {renderField(row.fields[1])}
+                    </Box>
                   </SimpleGrid>
                 ) : (
                   <Box key={row.field.name}>{renderField(row.field)}</Box>
@@ -752,7 +860,10 @@ const RuleEngineFormDialog = ({
               disabled={isSubmitting}
               leftSection={
                 isSubmitting ? (
-                  <Loader2 size={18} style={{ animation: "spin 1s linear infinite" }} />
+                  <Loader2
+                    size={18}
+                    style={{ animation: "spin 1s linear infinite" }}
+                  />
                 ) : undefined
               }
               radius="md"
diff --git a/apps/edr-freight-web/backoffice/src/components/ruleEngine/ruleEngineFormat.tsx b/apps/edr-freight-web/backoffice/src/components/ruleEngine/ruleEngineFormat.tsx
index 529f53a43..3a600cd5b 100644
--- a/apps/edr-freight-web/backoffice/src/components/ruleEngine/ruleEngineFormat.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/ruleEngine/ruleEngineFormat.tsx
@@ -25,12 +25,20 @@ export const formatCell = (
   row?: Record<string, unknown>,
 ): ReactNode => {
   if (value === null || value === undefined || value === "") {
-    return <Text size="sm" c="dimmed">—</Text>;
+    return (
+      <Text size="sm" c="dimmed">
+        —
+      </Text>
+    );
   }
 
   // Handle stringified objects (e.g., "[object Object]")
   if (typeof value === "string" && value.trim() === "[object Object]") {
-    return <Text size="sm" c="dimmed">—</Text>;
+    return (
+      <Text size="sm" c="dimmed">
+        —
+      </Text>
+    );
   }
 
   if (format === "boolean") {
@@ -75,9 +83,17 @@ export const formatCell = (
   if (format === "validityBadge") {
     const status = String(value);
     const label =
-      status === "VALID" ? "Valid" : status === "EXPIRED" ? "Expired" : "Not started";
+      status === "VALID"
+        ? "Valid"
+        : status === "EXPIRED"
+          ? "Expired"
+          : "Not started";
     const color =
-      status === "VALID" ? "edr-green" : status === "EXPIRED" ? "red" : "yellow";
+      status === "VALID"
+        ? "edr-green"
+        : status === "EXPIRED"
+          ? "red"
+          : "yellow";
     return (
       <Badge color={color} variant="filled" size="sm" radius="md">
         {label}
@@ -85,6 +101,20 @@ export const formatCell = (
     );
   }
 
+  if (format === "accountBadge") {
+    // `hasAccount` — whether a portal login backs this row. Roster-only rows
+    // predate accounts and stay legal, so "no" is a neutral dash, not a warning.
+    return value ? (
+      <Badge color="edr-green" variant="filled" size="sm" radius="md">
+        Invited
+      </Badge>
+    ) : (
+      <Text size="sm" c="dimmed">
+        —
+      </Text>
+    );
+  }
+
   if (format === "code") {
     return (
       <Badge
@@ -110,7 +140,11 @@ export const formatCell = (
 
   if (format === "number") {
     const num = Number(value);
-    return <Text size="sm">{Number.isNaN(num) ? String(value) : num.toLocaleString()}</Text>;
+    return (
+      <Text size="sm">
+        {Number.isNaN(num) ? String(value) : num.toLocaleString()}
+      </Text>
+    );
   }
 
   if (format === "currency") {
@@ -125,14 +159,13 @@ export const formatCell = (
 
   if (format === "date") {
     const d = new Date(String(value));
-    if (Number.isNaN(d.getTime())) return <Text size="sm">{String(value)}</Text>;
+    if (Number.isNaN(d.getTime()))
+      return <Text size="sm">{String(value)}</Text>;
     return <Text size="sm">{d.toLocaleDateString()}</Text>;
   }
 
   if (Array.isArray(value)) {
-    return (
-      <Text size="sm">{value.length > 0 ? value.join(", ") : "—"}</Text>
-    );
+    return <Text size="sm">{value.length > 0 ? value.join(", ") : "—"}</Text>;
   }
 
   if (format === "entityLabel" && value && typeof value === "object") {
@@ -140,7 +173,11 @@ export const formatCell = (
     if (label) {
       return <Text size="sm">{label}</Text>;
     }
-    return <Text size="sm" c="dimmed">—</Text>;
+    return (
+      <Text size="sm" c="dimmed">
+        —
+      </Text>
+    );
   }
 
   if (format === "rateLabel") {
@@ -150,7 +187,9 @@ export const formatCell = (
           {String(value)}
         </Text>
       ) : (
-        <Text size="sm" c="dimmed">—</Text>
+        <Text size="sm" c="dimmed">
+          —
+        </Text>
       );
     }
     const rate = value as {
@@ -168,14 +207,20 @@ export const formatCell = (
     return parts.length > 0 ? (
       <Text size="sm">{parts.join(" · ")}</Text>
     ) : (
-      <Text size="sm" c="dimmed">—</Text>
+      <Text size="sm" c="dimmed">
+        —
+      </Text>
     );
   }
 
   if (typeof value === "object") {
     const label = extractLabel(value);
     if (label) return <Text size="sm">{label}</Text>;
-    return <Text size="sm" c="dimmed">—</Text>;
+    return (
+      <Text size="sm" c="dimmed">
+        —
+      </Text>
+    );
   }
 
   return <Text size="sm">{String(value)}</Text>;
diff --git a/apps/edr-freight-web/backoffice/src/components/shipping-lines/ResendActivationAction.tsx b/apps/edr-freight-web/backoffice/src/components/shipping-lines/ResendActivationAction.tsx
index ae271a57b..e68725b52 100644
--- a/apps/edr-freight-web/backoffice/src/components/shipping-lines/ResendActivationAction.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/shipping-lines/ResendActivationAction.tsx
@@ -10,9 +10,10 @@ import {
 } from "@mantine/core";
 import { useMutation } from "@tanstack/react-query";
 import { Send } from "lucide-react";
-import { useState } from "react";
+import { useState, type ReactNode } from "react";
 
 import { useAuth } from "@/auth/useAuth";
+import { isSmsReachable } from "@/components/PhoneField";
 import { useToast } from "@/hooks/use-toast";
 import { FREIGHT_PERMS, hasPermission } from "@/lib/permissions";
 import { api } from "@/services/api";
@@ -21,27 +22,19 @@ import type {
   ShippingLineCompany,
 } from "@/types/shippingLineCompany";
 
-/**
- * Whether the SMS gateway can actually reach this number.
- *
- * The carrier integration is domestic-only: anything else is queued and
- * silently lost, so a foreign number counts as unavailable rather than as a
- * send that quietly fails. Mirrors `isDomesticPhone` in the API's otp.service.
- */
-function isDomesticPhone(rawPhone: string): boolean {
-  const digits = rawPhone.trim().replace(/[^\d+]/g, "");
-  const normalized = digits.startsWith("+")
-    ? digits
-    : /^251\d{9}$/.test(digits)
-      ? `+${digits}`
-      : /^9\d{8}$|^7\d{8}$/.test(digits.replace(/^0+/, ""))
-        ? `+251${digits.replace(/^0+/, "")}`
-        : digits;
-  return /^\+2519\d{8}$/.test(normalized);
+/** The minimum an account needs for the link dialog to describe its channels. */
+export interface ActivationTarget {
+  id: string;
+  name: string;
+  email?: string | null;
+  phoneNumber?: string | null;
 }
 
 export interface ResendActivationActionProps {
-  shippingLine: Pick<ShippingLineCompany, "id" | "name" | "email" | "phoneNumber">;
+  shippingLine: Pick<
+    ShippingLineCompany,
+    "id" | "name" | "email" | "phoneNumber"
+  >;
 }
 
 /**
@@ -56,15 +49,13 @@ export default function ResendActivationAction({
 }: ResendActivationActionProps) {
   const { user } = useAuth();
   const { toast } = useToast();
-  const [opened, setOpened] = useState(false);
-  const [channel, setChannel] = useState<ResetChannel>("email");
-
-  const allowed = hasPermission(user, FREIGHT_PERMS.shippingLines.resetPassword);
-
+  const allowed = hasPermission(
+    user,
+    FREIGHT_PERMS.shippingLines.resetPassword,
+  );
   const { mutate, isPending } = useMutation(
     api.shippingLineCompanies.resendActivation.mutationOptions({
       onSuccess: (result) => {
-        setOpened(false);
         toast({
           title: "Activation link sent",
           description: `The shipping line can set their password using the link sent to ${result.maskedTarget}. It expires in 24 hours.`,
@@ -82,42 +73,100 @@ export default function ResendActivationAction({
 
   if (!allowed) return null;
 
-  const phoneUsable =
-    !!shippingLine.phoneNumber && isDomesticPhone(shippingLine.phoneNumber);
+  return (
+    <ActivationLinkDialog
+      target={shippingLine}
+      audienceLabel="shipping line"
+      isPending={isPending}
+      onSend={(channel, onDone) =>
+        mutate({ id: shippingLine.id, channel }, { onSuccess: onDone })
+      }
+    />
+  );
+}
+
+export interface ActivationLinkDialogProps {
+  target: ActivationTarget;
+  /** How the account is described in the dialog copy ("shipping line", "transit agent"). */
+  audienceLabel: string;
+  isPending: boolean;
+  /**
+   * Perform the send. `onDone` closes the dialog — the caller owns the mutation
+   * (and its toast) because each audience posts to its own endpoint.
+   */
+  onSend: (channel: ResetChannel, onDone: () => void) => void;
+  /** Overrides the icon-button trigger, e.g. a labelled "Invite" button. */
+  trigger?: (open: () => void) => ReactNode;
+  title?: string;
+  submitLabel?: string;
+  /** Extra fields above the channel picker — the invite flow collects the address here. */
+  children?: ReactNode;
+  /** Blocks the send button, e.g. while a required address is still empty. */
+  submitDisabled?: boolean;
+}
+
+/**
+ * The channel picker behind every activation-link send.
+ *
+ * Extracted from the shipping-line action so transit agents get the identical
+ * dialog — including the domestic-only SMS rule, which is the part most likely
+ * to be re-implemented subtly wrong.
+ */
+export function ActivationLinkDialog({
+  target,
+  audienceLabel,
+  isPending,
+  onSend,
+  trigger,
+  title = "Resend activation link",
+  submitLabel = "Send activation link",
+  children,
+  submitDisabled,
+}: ActivationLinkDialogProps) {
+  const [opened, setOpened] = useState(false);
+  const [channel, setChannel] = useState<ResetChannel>("email");
+
+  const phoneUsable = isSmsReachable(target.phoneNumber);
   const channelMissing = channel === "phone" && !phoneUsable;
 
   return (
     <>
-      <Tooltip label="Resend activation link" withArrow>
-        <ActionIcon
-          variant="subtle"
-          color="gray"
-          aria-label={`Resend activation link to ${shippingLine.name}`}
-          onClick={(event) => {
-            // The row itself is not clickable today, but stop here anyway so
-            // adding a detail-page navigation later cannot swallow this click.
-            event.stopPropagation();
-            setOpened(true);
-          }}
-        >
-          <Send size={16} />
-        </ActionIcon>
-      </Tooltip>
+      {trigger ? (
+        trigger(() => setOpened(true))
+      ) : (
+        <Tooltip label={title} withArrow>
+          <ActionIcon
+            variant="subtle"
+            color="gray"
+            aria-label={`${title} to ${target.name}`}
+            onClick={(event) => {
+              // The row itself is not clickable today, but stop here anyway so
+              // adding a detail-page navigation later cannot swallow this click.
+              event.stopPropagation();
+              setOpened(true);
+            }}
+          >
+            <Send size={16} />
+          </ActionIcon>
+        </Tooltip>
+      )}
 
       <Modal
         opened={opened}
         onClose={() => setOpened(false)}
-        title="Resend activation link"
+        title={title}
         centered
       >
         <Stack gap="md">
           <Text size="sm" c="dimmed">
-            We&apos;ll send a single-use link to {shippingLine.name}. They choose
-            their own password — you will not see it. The link expires in 24
-            hours, and sending a new one invalidates nothing they haven&apos;t
-            already used.
+            We&apos;ll send a single-use link to this {audienceLabel},{" "}
+            {target.name}. They choose their own password — you will not see it.
+            The link expires in 24 hours, and sending a new one invalidates
+            nothing they haven&apos;t already used.
           </Text>
 
+          {children}
+
           <Radio.Group
             value={channel}
             onChange={(v) => setChannel(v as ResetChannel)}
@@ -127,18 +176,19 @@ export default function ResendActivationAction({
               <Radio
                 value="email"
                 label="Email"
-                description={shippingLine.email}
+                disabled={!target.email}
+                description={target.email ?? "No email on this account"}
               />
               <Radio
                 value="phone"
                 label="SMS"
                 disabled={!phoneUsable}
                 description={
-                  !shippingLine.phoneNumber
+                  !target.phoneNumber
                     ? "No phone number on this account"
                     : !phoneUsable
-                      ? `${shippingLine.phoneNumber} — foreign number, SMS unavailable; use email`
-                      : shippingLine.phoneNumber
+                      ? `${target.phoneNumber} — the SMS gateway does not reach this number; use email`
+                      : target.phoneNumber
                 }
               />
             </Stack>
@@ -156,10 +206,10 @@ export default function ResendActivationAction({
           <Button
             color="edr-green"
             loading={isPending}
-            disabled={channelMissing}
-            onClick={() => mutate({ id: shippingLine.id, channel })}
+            disabled={channelMissing || submitDisabled}
+            onClick={() => onSend(channel, () => setOpened(false))}
           >
-            Send activation link
+            {submitLabel}
           </Button>
         </Stack>
       </Modal>
diff --git a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
index f63abe12d..a7d8f0323 100644
--- a/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
+++ b/apps/edr-freight-web/backoffice/src/components/trainScheduling/ScheduleWorkspacePanel.tsx
@@ -303,6 +303,7 @@ export function ScheduleWorkspacePanel({
   const [moveBookingId, setMoveBookingId] = useState<string | null>(null);
   // Per-wagon loading/unloading modal for one booking.
   const [wagonModal, setWagonModal] = useState<{
+    isExport: boolean;
     bookingId: string;
     ref: string;
     phase: "load" | "unload";
@@ -908,7 +909,12 @@ export function ScheduleWorkspacePanel({
                                   radius="md"
                                   disabled={!canLoad || !loadWindowStarted}
                                   onClick={() =>
-                                    setWagonModal({ bookingId: b.id, ref, phase: "load" })
+                                    setWagonModal({
+                                      bookingId: b.id,
+                                      ref,
+                                      phase: "load",
+                                      isExport: b.tradeDirection === "EXPORT",
+                                    })
                                   }
                                 >
                                   Wagons
@@ -987,7 +993,12 @@ export function ScheduleWorkspacePanel({
                                   radius="md"
                                   disabled={!canUnload || !unloadWindowStarted}
                                   onClick={() =>
-                                    setWagonModal({ bookingId: b.id, ref, phase: "unload" })
+                                    setWagonModal({
+                                      bookingId: b.id,
+                                      ref,
+                                      phase: "unload",
+                                      isExport: b.tradeDirection === "EXPORT",
+                                    })
                                   }
                                 >
                                   Wagons
@@ -1035,6 +1046,7 @@ export function ScheduleWorkspacePanel({
           bookingId={wagonModal.bookingId}
           reference={wagonModal.ref}
           phase={wagonModal.phase}
+          isExport={wagonModal.isExport}
           onClose={() => setWagonModal(null)}
           onChanged={onChanged}
         />
@@ -1423,6 +1435,7 @@ function PerWagonModal({
   bookingId,
   reference,
   phase,
+  isExport,
   onClose,
   onChanged,
 }: {
@@ -1430,13 +1443,35 @@ function PerWagonModal({
   bookingId: string;
   reference: string;
   phase: "load" | "unload";
+  /**
+   * EXPORT booking — only these may use the truck-to-train submit, which is
+   * what the server's handover-mode endpoint enforces too (it 400s on any
+   * other direction).
+   */
+  isExport: boolean;
   onClose: () => void;
   onChanged: () => void;
 }) {
   const { toast } = useToast();
-  const [cancelOpen, setCancelOpen] = useState(false);
+
   const [reason, setReason] = useState("");
   const [edrFault, setEdrFault] = useState(false);
+  // Wagons ticked for this submit. Load is a batch action now: pick the wagons
+  // that physically went on, then submit once.
+  const [picked, setPicked] = useState<Set<string>>(new Set());
+  // Which submit is in flight — also decides whether the handover mode is set
+  // first ("truck") or the GRN gate is left to reject ("load").
+  const [submitting, setSubmitting] = useState<null | "load" | "truck">(null);
+  // Submit awaiting confirmation. Loading is irreversible from this screen —
+  // there is no "unload back to the yard" here — and truck-to-train also drops
+  // the booking's GRN requirement for good, so both go through a confirm step.
+  // The one open panel, if any. A single slot rather than a flag per panel:
+  // separate booleans let the cancel form and a submit confirm show at the same
+  // time, each with its own buttons.
+  const [confirmSubmit, setConfirmSubmit] = useState<null | "load" | "truck" | "cancel">(
+    null,
+  );
+  const cancelOpen = confirmSubmit === "cancel";
 
   const wagonsQuery = useQuery(api.trainScheduling.bookingWagons.queryOptions({
     input: { bookingId },
@@ -1463,41 +1498,118 @@ function PerWagonModal({
       ? ((err.response?.data as { message?: string })?.message ?? err.message)
       : String(err);
 
-  const onWagon = (allocationId: string) => {
-    act
-      .mutateAsync({ scheduleId, bookingId, allocationId })
-      .then((r) => {
-        void wagonsQuery.refetch();
-        if (r.completed) {
-          toast({
-            title: phase === "load" ? "Booking fully loaded" : "Booking fully unloaded",
-            description: `${reference}: every wagon is ${phase === "load" ? "loaded — the booking is in transit" : "unloaded — the booking arrived"}.`,
+  const toggle = (allocationId: string) =>
+    setPicked((prev) => {
+      const next = new Set(prev);
+      if (next.has(allocationId)) next.delete(allocationId);
+      else next.add(allocationId);
+      return next;
+    });
+
+  const pickedPending = pending.filter((w) => picked.has(w.allocationId));
+
+  /**
+   * Submit the ticked wagons. There is no batch endpoint, so they go one at a
+   * time in order — the server flips the booking to IN_TRANSIT on whichever
+   * call clears the last unloaded wagon, so sequential is required, not just
+   * convenient. The first failure stops the run: the wagons already sent stay
+   * loaded (each call is its own transaction) and the toast names the survivor
+   * count, so a retry only resends what is left.
+   *
+   * `mode: "truck"` first sets DIRECT_TO_TRAIN, which is what makes the GRN
+   * gate let this booking through — see assertExportReceivedWithGrn. Plain
+   * "load" sends nothing extra and lets that gate reject unreceived cargo.
+   */
+  const onSubmit = (mode: "load" | "truck") => {
+    const targets = pickedPending;
+    if (!targets.length) return;
+    setConfirmSubmit(null);
+    setSubmitting(mode);
+
+    const run = async () => {
+      if (mode === "truck") {
+        await bookingsService.setExportHandoverMode(bookingId, "DIRECT_TO_TRAIN");
+      }
+      let done = 0;
+      let completed = false;
+      try {
+        for (const w of targets) {
+          const r = await act.mutateAsync({
+            scheduleId,
+            bookingId,
+            allocationId: w.allocationId,
           });
-          onChanged();
-          onClose();
-        } else {
+          done += 1;
+          if (r.completed) completed = true;
+        }
+      } catch (err) {
+        // Partial success is a real outcome here, not a rollback candidate:
+        // report what landed so the operator knows what to retry.
+        if (done > 0) {
+          void wagonsQuery.refetch();
           onChanged();
         }
+        throw Object.assign(err as Error, { partial: done });
+      }
+      return { done, completed };
+    };
+
+    run()
+      .then(({ done, completed }) => {
+        void wagonsQuery.refetch();
+        onChanged();
+        setPicked(new Set());
+        if (completed) {
+          toast({
+            title: phase === "load" ? "Booking fully loaded" : "Booking fully unloaded",
+            description:
+              phase === "load"
+                ? `${reference}: every wagon is loaded — the booking is in transit${mode === "truck" ? " (direct truck-to-train handover)" : ""}.`
+                : `${reference}: every wagon is unloaded — the booking arrived.`,
+          });
+          onClose();
+        } else {
+          toast({
+            title: phase === "load" ? "Wagons loaded" : "Wagons unloaded",
+            description: `${reference}: ${done} wagon${done === 1 ? "" : "s"} ${phase === "load" ? "loaded" : "unloaded"}.`,
+          });
+        }
       })
-      .catch((err) =>
+      .catch((err) => {
+        const sent = (err as { partial?: number }).partial ?? 0;
         toast({
           title: phase === "load" ? "Wagon load failed" : "Wagon unload failed",
-          description: errText(err),
+          description: sent
+            ? `${sent} wagon(s) went through before this: ${errText(err)}`
+            : errText(err),
           variant: "destructive",
-        }),
-      );
+        });
+      })
+      .finally(() => setSubmitting(null));
   };
 
   const onCancelRemaining = () => {
+    // Cut exactly the ticked wagons. Sending the ids (rather than omitting them
+    // and letting the server cut the whole remainder) is what makes a partial
+    // cancel possible while other wagons are still waiting to load.
+    const ids = pickedPending.map((w) => w.allocationId);
+    const count = ids.length;
     cancelRemaining
-      .mutateAsync({ bookingId, scheduleId, reason: reason.trim(), edrFault })
+      .mutateAsync({
+        bookingId,
+        scheduleId,
+        reason: reason.trim(),
+        edrFault,
+        wagonAllocationIds: ids,
+      })
       .then(() => {
         toast({
-          title: "Remaining wagons cancelled",
+          title: "Wagons cancelled",
           description: edrFault
-            ? `${reference}: ${pending.length} wagon(s) cancelled at EDR's fault — no fee charged; the credit is rebookable.`
-            : `${reference}: ${pending.length} wagon(s) cancelled — the cancellation fee was invoiced to the customer; the credit is rebookable.`,
+            ? `${reference}: ${count} wagon(s) cancelled at EDR's fault — no fee charged; the credit is rebookable.`
+            : `${reference}: ${count} wagon(s) cancelled — the cancellation fee was invoiced to the customer; the credit is rebookable.`,
         });
+        setPicked(new Set());
         onChanged();
         onClose();
       })
@@ -1550,6 +1662,15 @@ function PerWagonModal({
             <Paper key={w.allocationId} withBorder radius="md" p="xs">
               <Group justify="space-between" wrap="nowrap">
                 <Group gap={8} wrap="nowrap" style={{ minWidth: 0 }}>
+                  {!isDone(w) ? (
+                    <Checkbox
+                      checked={picked.has(w.allocationId)}
+                      onChange={() => toggle(w.allocationId)}
+                      disabled={submitting != null}
+                      color={phase === "load" ? "edr-green" : "orange"}
+                      aria-label={`Select wagon ${w.sequenceNo ?? ""} to ${phase}`}
+                    />
+                  ) : null}
                   <Badge size="sm" radius="sm" variant="outline" color="gray">
                     {w.sequenceNo != null ? `#${w.sequenceNo}` : "—"}
                   </Badge>
@@ -1574,50 +1695,216 @@ function PerWagonModal({
                   >
                     {phase === "load" ? "Loaded" : "Unloaded"}
                   </Badge>
-                ) : (
-                  <Button
-                    size="compact-sm"
-                    variant="filled"
-                    color={phase === "load" ? "edr-green" : "orange"}
-                    radius="md"
-                    leftSection={
-                      phase === "load" ? <PackageCheck size={13} /> : <PackageOpen size={13} />
-                    }
-                    loading={
-                      act.isPending && act.variables?.allocationId === w.allocationId
-                    }
-                    onClick={() => onWagon(w.allocationId)}
-                  >
-                    {phase === "load" ? "Load" : "Unload"}
-                  </Button>
-                )}
+                ) : null}
               </Group>
             </Paper>
           ))
         )}
 
-        {phase === "load" && doneCount > 0 && pending.length > 0 ? (
-          !cancelOpen ? (
-            <Button
-              variant="light"
-              color="red"
-              radius="md"
-              leftSection={<X size={14} />}
-              onClick={() => setCancelOpen(true)}
-            >
-              Cancel the {pending.length} remaining wagon{pending.length === 1 ? "" : "s"}…
-            </Button>
-          ) : (
-            <Paper withBorder radius="md" p="sm">
+        {pending.length > 0 && !confirmSubmit ? (
+          <Group justify="space-between" wrap="wrap" gap="sm">
+            <Group gap={8}>
+              <Button
+                size="compact-sm"
+                variant="subtle"
+                radius="md"
+                disabled={submitting != null}
+                onClick={() =>
+                  setPicked(
+                    picked.size === pending.length
+                      ? new Set()
+                      : new Set(pending.map((w) => w.allocationId)),
+                  )
+                }
+              >
+                {picked.size === pending.length ? "Clear all" : "Select all"}
+              </Button>
+              <Text size="xs" c="dimmed">
+                {pickedPending.length} of {pending.length} selected
+              </Text>
+            </Group>
+            <Group gap="sm">
+              {phase === "load" ? (
+                <Tooltip
+                  label="Cancel the selected wagons — they will not ride. Customer fault invoices the cancellation fee; EDR fault charges nothing."
+                  withArrow
+                >
+                  <Button
+                    variant="light"
+                    color="red"
+                    radius="md"
+                    leftSection={<X size={14} />}
+                    disabled={!pickedPending.length || submitting != null}
+                    onClick={() => setConfirmSubmit("cancel")}
+                  >
+                    Cancel
+                  </Button>
+                </Tooltip>
+              ) : null}
+              {phase === "load" && isExport ? (
+                <Tooltip
+                  label="Customer truck loaded straight onto the wagon — no warehouse receipt, no GRN. Sets direct truck-to-train handover, then loads the selected wagons."
+                  withArrow
+                >
+                  <Button
+                    variant="light"
+                    color="blue"
+                    radius="md"
+                    leftSection={<Truck size={14} />}
+                    disabled={!pickedPending.length || submitting != null}
+                    loading={submitting === "truck"}
+                    onClick={() => setConfirmSubmit("truck")}
+                  >
+                    Truck to train
+                  </Button>
+                </Tooltip>
+              ) : null}
+              <Tooltip
+                label={
+                  phase === "load"
+                    ? "Load the selected wagons — export cargo must already be received at the warehouse with a GRN."
+                    : "Unload the selected wagons."
+                }
+                withArrow
+              >
+                <Button
+                  color={phase === "load" ? "edr-green" : "orange"}
+                  radius="md"
+                  leftSection={
+                    phase === "load" ? <PackageCheck size={14} /> : <PackageOpen size={14} />
+                  }
+                  disabled={!pickedPending.length || submitting != null}
+                  loading={submitting === "load"}
+                  onClick={() => setConfirmSubmit("load")}
+                >
+                  {phase === "load" ? "Load" : "Unload"} {pickedPending.length || ""}
+                </Button>
+              </Tooltip>
+            </Group>
+          </Group>
+        ) : null}
+
+        {confirmSubmit && confirmSubmit !== "cancel" ? (
+          <Paper withBorder radius="md" p="sm">
+            <Stack gap="xs">
+              <Group gap={10} wrap="nowrap">
+                <ThemeIcon
+                  size={40}
+                  radius="md"
+                  variant="light"
+                  color={
+                    confirmSubmit === "truck"
+                      ? "blue"
+                      : phase === "load"
+                        ? "edr-green"
+                        : "orange"
+                  }
+                >
+                  {confirmSubmit === "truck" ? (
+                    <Truck size={21} />
+                  ) : phase === "load" ? (
+                    <PackageCheck size={21} />
+                  ) : (
+                    <PackageOpen size={21} />
+                  )}
+                </ThemeIcon>
+                <div>
+                  <Text fw={800}>
+                    {confirmSubmit === "truck"
+                      ? "Load as direct truck-to-train?"
+                      : phase === "load"
+                        ? `Load ${pickedPending.length} wagon${pickedPending.length === 1 ? "" : "s"}?`
+                        : `Unload ${pickedPending.length} wagon${pickedPending.length === 1 ? "" : "s"}?`}
+                  </Text>
+                  <Text size="xs" c="dimmed">
+                    {reference}
+                  </Text>
+                </div>
+              </Group>
+              <Text size="sm">
+                {confirmSubmit === "truck"
+                  ? `Sets direct truck-to-train handover for the whole booking (no warehouse receipt, no GRN — the carriage acceptance sheet becomes the handover document), then loads the ${pickedPending.length} selected wagon${pickedPending.length === 1 ? "" : "s"}.`
+                  : phase === "load"
+                    ? "Stamps the selected wagons as loaded at this yard. Export cargo must already be received at the warehouse with a GRN."
+                    : "Stamps the selected wagons as unloaded and frees them for reuse."}
+              </Text>
+              {confirmSubmit === "truck" ? (
+                <Group
+                  gap={8}
+                  p="xs"
+                  wrap="nowrap"
+                  style={{
+                    borderRadius: 10,
+                    background: "var(--mantine-color-yellow-0)",
+                    border: "1px solid var(--mantine-color-yellow-3)",
+                  }}
+                >
+                  <AlertTriangle size={16} color="#B54708" />
+                  <Text size="xs" c="yellow.9" fw={500}>
+                    The handover mode applies to the whole booking and stays set
+                    even if a wagon then fails to load — its GRN requirement is
+                    dropped for good.
+                  </Text>
+                </Group>
+              ) : null}
+              {pickedPending.length < pending.length ? (
+                <Text size="xs" c="dimmed">
+                  {pending.length - pickedPending.length} wagon
+                  {pending.length - pickedPending.length === 1 ? "" : "s"} left
+                  un{phase === "load" ? "loaded" : "unloaded"} — the train cannot
+                  dispatch until they are {phase === "load" ? "loaded" : "unloaded"} or
+                  cancelled.
+                </Text>
+              ) : null}
+              <Group justify="flex-end" gap="sm">
+                <Button variant="default" radius="md" onClick={() => setConfirmSubmit(null)}>
+                  Back
+                </Button>
+                <Button
+                  color={
+                    confirmSubmit === "truck"
+                      ? "blue"
+                      : phase === "load"
+                        ? "edr-green"
+                        : "orange"
+                  }
+                  radius="md"
+                  leftSection={
+                    confirmSubmit === "truck" ? (
+                      <Truck size={14} />
+                    ) : phase === "load" ? (
+                      <PackageCheck size={14} />
+                    ) : (
+                      <PackageOpen size={14} />
+                    )
+                  }
+                  onClick={() => onSubmit(confirmSubmit === "truck" ? "truck" : "load")}
+                >
+                  {confirmSubmit === "truck"
+                    ? "Load direct"
+                    : phase === "load"
+                      ? "Load"
+                      : "Unload"}
+                </Button>
+              </Group>
+            </Stack>
+          </Paper>
+        ) : null}
+
+        {phase === "load" && cancelOpen && pickedPending.length > 0 ? (
+          <Paper withBorder radius="md" p="sm">
               <Stack gap="xs">
                 <Text size="sm" fw={600}>
-                  Cancel {pending.length} unloaded wagon
-                  {pending.length === 1 ? "" : "s"} of {reference}
+                  Cancel {pickedPending.length} selected wagon
+                  {pickedPending.length === 1 ? "" : "s"} of {reference}
                 </Text>
                 <Text size="xs" c="dimmed">
-                  The booking shrinks to its loaded wagons and the freed freight
+                  These wagons are cut from the booking and the freed freight
                   becomes a rebookable credit. Customer fault: the cancellation
                   fee is invoiced, payable afterwards. EDR fault: no fee.
+                  {pending.length > pickedPending.length
+                    ? ` The other ${pending.length - pickedPending.length} unloaded wagon(s) stay on the booking and still have to be loaded or cancelled before dispatch.`
+                    : ""}
                 </Text>
                 <Textarea
                   label="Reason"
@@ -1633,7 +1920,7 @@ function PerWagonModal({
                   onChange={(e) => setEdrFault(e.currentTarget.checked)}
                 />
                 <Group justify="flex-end" gap="sm">
-                  <Button variant="default" radius="md" onClick={() => setCancelOpen(false)}>
+                  <Button variant="default" radius="md" onClick={() => setConfirmSubmit(null)}>
                     Back
                   </Button>
                   <Button
@@ -1647,8 +1934,7 @@ function PerWagonModal({
                   </Button>
                 </Group>
               </Stack>
-            </Paper>
-          )
+          </Paper>
         ) : null}
       </Stack>
     </Modal>
diff --git a/apps/edr-freight-web/backoffice/src/components/transit-agents/TransitAgentAccountAction.tsx b/apps/edr-freight-web/backoffice/src/components/transit-agents/TransitAgentAccountAction.tsx
new file mode 100644
index 000000000..65bcc0fce
--- /dev/null
+++ b/apps/edr-freight-web/backoffice/src/components/transit-agents/TransitAgentAccountAction.tsx
@@ -0,0 +1,156 @@
+import { Button, Stack, TextInput, Tooltip } from "@mantine/core";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useState } from "react";
+
+import PhoneField, { isValidPhone } from "@/components/PhoneField";
+import { ActivationLinkDialog } from "@/components/shipping-lines/ResendActivationAction";
+import { QUERY_KEYS } from "@/constants/QUERY_KEYS";
+import { useToast } from "@/hooks/use-toast";
+import { transitAgentsService } from "@/services/transit-agents.service";
+import type { TransitAgent } from "@/services/transit-agents.service";
+import type { ResetChannel } from "@/types/shippingLineCompany";
+
+export interface TransitAgentAccountActionProps {
+  agent: TransitAgent;
+  /** Hidden entirely without the update permission, matching the other row controls. */
+  disabled?: boolean;
+}
+
+/**
+ * The account column's row control: **Invite** for an agent that has no portal
+ * login yet, **Resend** for one that has.
+ *
+ * Inviting is deliberately its own action rather than a side effect of editing
+ * the email: it mints an IAM user, and a field edit must never do that
+ * implicitly — the roster rows that predate portal logins would start growing
+ * accounts the first time anyone corrected a typo.
+ */
+export default function TransitAgentAccountAction({
+  agent,
+  disabled,
+}: TransitAgentAccountActionProps) {
+  const { toast } = useToast();
+  const queryClient = useQueryClient();
+  const [email, setEmail] = useState(agent.email ?? "");
+  const [phoneNumber, setPhoneNumber] = useState(agent.phoneNumber ?? "");
+
+  const invalidate = () =>
+    queryClient.invalidateQueries({ queryKey: QUERY_KEYS.RULE_ENGINE.ROOT });
+
+  const invite = useMutation({
+    mutationFn: () =>
+      transitAgentsService.invite(agent.id, {
+        email: email.trim(),
+        phoneNumber: phoneNumber.trim() || undefined,
+      }),
+    onSuccess: async (result) => {
+      await invalidate();
+      toast({
+        title: "Portal account created",
+        description: result.activationSentTo
+          ? `${agent.name} can set their password using the link sent to ${result.activationSentTo}. It expires in 24 hours.`
+          : `${agent.name} now has a portal account, but the activation link could not be sent — resend it.`,
+      });
+    },
+    onError: (error: Error) =>
+      toast({
+        title: "Could not create the portal account",
+        description: error.message,
+        variant: "destructive",
+      }),
+  });
+
+  const resend = useMutation({
+    mutationFn: (channel: ResetChannel) =>
+      transitAgentsService.resendActivation(agent.id, channel),
+    onSuccess: (result) =>
+      toast({
+        title: "Activation link sent",
+        description: `${agent.name} can set their password using the link sent to ${result.maskedTarget}. It expires in 24 hours.`,
+      }),
+    onError: (error: Error) =>
+      toast({
+        title: "Could not send activation link",
+        description: error.message,
+        variant: "destructive",
+      }),
+  });
+
+  if (disabled) return null;
+
+  // Already has a login — the only thing left is another copy of the link, so
+  // this is exactly the shipping-line dialog with a different endpoint behind it.
+  if (agent.hasAccount) {
+    return (
+      <ActivationLinkDialog
+        target={agent}
+        audienceLabel="transit agent"
+        isPending={resend.isPending}
+        onSend={(channel, onDone) =>
+          resend.mutate(channel, { onSuccess: onDone })
+        }
+        trigger={(open) => (
+          <Tooltip label="Resend activation link" withArrow>
+            <Button size="compact-xs" variant="light" onClick={open}>
+              Resend
+            </Button>
+          </Tooltip>
+        )}
+      />
+    );
+  }
+
+  return (
+    <ActivationLinkDialog
+      // Show the addresses being typed, not the (empty) stored ones, so the
+      // channel picker enables SMS as soon as a domestic number is entered.
+      target={{
+        ...agent,
+        email: email.trim() || null,
+        phoneNumber: phoneNumber.trim() || null,
+      }}
+      audienceLabel="transit agent"
+      isPending={invite.isPending}
+      title="Create portal account"
+      submitLabel="Create account and send link"
+      // The channel choice is the dialog's, but invite always emails (and texts
+      // a domestic number) — the API picks both. Sending is what matters here.
+      // A half-typed number is a non-empty partial E.164 the API rejects with a
+      // 400 — block it here rather than posting it.
+      submitDisabled={
+        !email.trim() || (!!phoneNumber.trim() && !isValidPhone(phoneNumber))
+      }
+      onSend={(_channel, onDone) =>
+        invite.mutate(undefined, { onSuccess: onDone })
+      }
+      trigger={(open) => (
+        <Tooltip label="Give this agent a portal login" withArrow>
+          <Button size="compact-xs" variant="light" onClick={open}>
+            Invite
+          </Button>
+        </Tooltip>
+      )}
+    >
+      <Stack gap="sm">
+        <TextInput
+          label="Email"
+          placeholder="a.bourhan@transit.dj"
+          required
+          value={email}
+          onChange={(e) => setEmail(e.currentTarget.value)}
+        />
+        <PhoneField
+          label="Phone number"
+          value={phoneNumber}
+          onChange={(v) => setPhoneNumber(v ?? "")}
+          error={
+            phoneNumber.trim() && !isValidPhone(phoneNumber)
+              ? "Enter the complete number"
+              : undefined
+          }
+          description="Ethiopian and Djiboutian mobiles also receive the link by SMS"
+        />
+      </Stack>
+    </ActivationLinkDialog>
+  );
+}
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/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/constants/URLS.ts b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
index 8603444d2..d09b9f4c5 100644
--- a/apps/edr-freight-web/backoffice/src/constants/URLS.ts
+++ b/apps/edr-freight-web/backoffice/src/constants/URLS.ts
@@ -281,6 +281,7 @@ export const URL_CONSTANTS = {
     STAFF_REQUEST_CHANGES: (id: string) =>
       `/contracts/${id}/staff/request-changes`,
     STAFF_REJECT: (id: string) => `/contracts/${id}/staff/reject`,
+    STAFF_CANCEL: (id: string) => `/contracts/${id}/staff/cancel`,
     SUSPEND: (id: string) => `/contracts/${id}/suspend`,
     RESUME: (id: string) => `/contracts/${id}/resume`,
     APPROVE_STEP: (id: string, stepId: string) =>
@@ -615,6 +616,10 @@ export const URL_CONSTANTS = {
     TRANSIT_AGENTS: "/transit-agents",
     TRANSIT_AGENT_BY_ID: (id: string) => `/transit-agents/${id}`,
     TRANSIT_AGENTS_ASSIGNABLE: "/transit-agents/assignable",
+    /** Give an existing roster-only agent a portal account and send the link. */
+    TRANSIT_AGENT_INVITE: (id: string) => `/transit-agents/${id}/invite`,
+    TRANSIT_AGENT_RESEND_ACTIVATION: (id: string) =>
+      `/transit-agents/${id}/resend-activation`,
   },
   RATE_MATRIX: {
     BASE: "/api/rate-matrices",
@@ -652,6 +657,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: {
@@ -666,6 +681,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",
@@ -707,6 +726,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",
diff --git a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
index bc0697996..3ee56f916 100644
--- a/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
+++ b/apps/edr-freight-web/backoffice/src/hooks/contracts/useContracts.ts
@@ -151,6 +151,14 @@ export function useContractMutations(contractId: string) {
     onError: (error) => toast.error(extractErrorMessage(error, "Failed to reject contract")),
   });
 
+  const cancelByStaff = useMutation({
+    mutationFn: (reason: string) =>
+      contractsService.cancelByStaff(contractId, reason),
+    onSuccess: (data) => onSuccess(data, "Contract cancelled"),
+    onError: (error) =>
+      toast.error(extractErrorMessage(error, "Failed to cancel contract")),
+  });
+
   const suspend = useMutation({
     mutationFn: (reason: string) => contractsService.suspend(contractId, reason),
     onSuccess: (data) => onSuccess(data, "Contract suspended"),
@@ -269,6 +277,7 @@ export function useContractMutations(contractId: string) {
     updateDocument,
     requestChanges,
     reject,
+    cancelByStaff,
     suspend,
     resume,
     approveStep,
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/permissions.ts b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
index b3d721eb5..62137496f 100644
--- a/apps/edr-freight-web/backoffice/src/lib/permissions.ts
+++ b/apps/edr-freight-web/backoffice/src/lib/permissions.ts
@@ -96,6 +96,7 @@ export const FREIGHT_PERMS = {
     clearanceEtActions: "edr_freight_app:contracts:clearance_et_actions",
     clearanceDjActions: "edr_freight_app:contracts:clearance_dj_actions",
     suspend: "edr_freight_app:contracts:suspend",
+    cancel: "edr_freight_app:contracts:cancel",
     editDocument: "edr_freight_app:contracts:edit_document",
     finalInvoiceRaise: "edr_freight_app:contracts:final_invoice_raise",
     finalInvoiceConfirm: "edr_freight_app:contracts:final_invoice_confirm",
@@ -307,6 +308,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/BookingRequestDetailPage.tsx b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
index 88ac1218d..c372f5829 100644
--- a/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/bookings/BookingRequestDetailPage.tsx
@@ -40,6 +40,7 @@ import {
 } from "@mantine/core";
 
 import { PageContainer, PageHeader, KpiStrip } from "@/components/page";
+import { extractDownloadErrorMessage } from "@/components/warehouses/options";
 import type { KpiItem } from "@/components/page";
 import { EntityLink } from "@/components/detail";
 import { BookingActionsToolbar } from "@/components/bookings/BookingActionsToolbar";
@@ -374,11 +375,9 @@ export default function BookingRequestDetailPage() {
                       a.click();
                       URL.revokeObjectURL(url);
                     } catch (error) {
-                      toast.error(
-                        error instanceof Error
-                          ? error.message
-                          : "Carriage acceptance sheet is not available yet",
-                      );
+                      // Blob response: the JSON reason is inside the Blob, so
+                      // the sync path would show only "status code 400".
+                      toast.error(await extractDownloadErrorMessage(error));
                     }
                   }}
                 >
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
index 6ec28c27b..02b3979d7 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/RuleEngineResourcePage.tsx
@@ -26,6 +26,8 @@ import { PageContainer, PageHeader } from "@/components/page";
 import ManageRuleEngineOrderDialog from "@/components/ruleEngine/ManageRuleEngineOrderDialog";
 import PriorityRuleApprovalsSection from "@/pages/ruleEngine/PriorityRuleApprovalsSection";
 import RateApprovalsSection from "@/pages/ruleEngine/RateApprovalsSection";
+import TransitAgentAccountAction from "@/components/transit-agents/TransitAgentAccountAction";
+import type { TransitAgent } from "@/services/transit-agents.service";
 import { YardDesksModal } from "@/pages/ruleEngine/YardDesksModal";
 import { nextPriorityRangeStart } from "@/pages/ruleEngine/priorityRuleRange";
 import RuleEngineCardGrid from "@/components/ruleEngine/RuleEngineCardGrid";
@@ -577,8 +579,9 @@ const RuleEngineResourcePage = () => {
     base.push({
       id: "actions",
       header: "Actions",
-      size: config.orderConfig ? 200 : 140,
-      minSize: config.orderConfig ? 180 : 120,
+      // Transit agents carry an extra Invite/Resend button in this cell.
+      size: config.orderConfig ? 200 : config.slug === "transit-agents" ? 200 : 140,
+      minSize: config.orderConfig ? 180 : config.slug === "transit-agents" ? 180 : 120,
       meta: {
         headerClassName,
         cellClassName: `${cellClassName} whitespace-nowrap`,
@@ -597,6 +600,12 @@ const RuleEngineResourcePage = () => {
                 </Button>
               </Tooltip>
             ) : null}
+            {config.slug === "transit-agents" ? (
+              <TransitAgentAccountAction
+                agent={row.original as unknown as TransitAgent}
+                disabled={!canUpdateControls}
+              />
+            ) : null}
             {config.orderConfig && canUpdateControls ? (
               <RuleEngineOrderControls
                 record={row.original}
diff --git a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
index 273c535e8..22266212e 100644
--- a/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
+++ b/apps/edr-freight-web/backoffice/src/pages/ruleEngine/config/resources.ts
@@ -11,13 +11,14 @@ export type ColumnFormat =
   | "activeBadge"
   | "rateStatus"
   | "validityBadge"
+  | "accountBadge"
   | "date"
   | "number"
   | "currency"
   | "entityLabel"
   | "rateLabel";
 
-export type FormFieldType = "text" | "number" | "boolean" | "date" | "email" | "select" | "multiselect" | "textarea" | "radio" | "tierList";
+export type FormFieldType = "text" | "number" | "boolean" | "date" | "email" | "phone" | "select" | "multiselect" | "textarea" | "radio" | "tierList";
 
 export interface ResourceColumn {
   id: string;
@@ -669,6 +670,12 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
         accessorKey: "validityStatus",
         format: "validityBadge",
       },
+      {
+        id: "hasAccount",
+        header: "Portal account",
+        accessorKey: "hasAccount",
+        format: "accountBadge",
+      },
       activeColumn,
     ],
     formFields: [
@@ -681,6 +688,21 @@ export const RULE_ENGINE_RESOURCES: RuleEngineResourceConfig[] = [
         required: true,
         description: "Expired or not-yet-started agents can't be assigned — extend the dates or add a new one",
       },
+      {
+        name: "email",
+        label: "Email",
+        type: "email",
+        optional: true,
+        description:
+          "Filling this on create makes the portal account and emails the activation link. On an existing agent, use the Invite button instead — editing here only corrects the address.",
+      },
+      {
+        name: "phoneNumber",
+        label: "Phone number",
+        type: "phone",
+        optional: true,
+        description: "Ethiopian and Djiboutian mobiles also receive the link by SMS",
+      },
       { name: "isActive", label: "Active", type: "boolean", description: "Off suspends the officer regardless of the validity window" },
     ],
   },
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 31a0f35c0..4f079d9ea 100644
--- a/apps/edr-freight-web/backoffice/src/services/api.ts
+++ b/apps/edr-freight-web/backoffice/src/services/api.ts
@@ -153,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 {
@@ -984,13 +993,25 @@ export const api = {
     ),
 
     cancelRemainingWagons: endpoint<
-      { bookingId: string; scheduleId: string; reason: string; edrFault?: boolean },
+      {
+        bookingId: string;
+        scheduleId: string;
+        reason: string;
+        edrFault?: boolean;
+        /** Cut only these never-loaded wagons; omit for the whole remainder. */
+        wagonAllocationIds?: string[];
+      },
       unknown
     >(
       "train-scheduling",
       "cancel-remaining-wagons",
-      ({ bookingId, scheduleId, reason, edrFault }) =>
-        trainSchedulingService.cancelRemainingWagons(bookingId, { scheduleId, reason, edrFault }),
+      ({ bookingId, scheduleId, reason, edrFault, wagonAllocationIds }) =>
+        trainSchedulingService.cancelRemainingWagons(bookingId, {
+          scheduleId,
+          reason,
+          edrFault,
+          wagonAllocationIds,
+        }),
       undefined,
       () => TRAIN_SCHEDULING_INVALIDATIONS,
     ),
@@ -1211,6 +1232,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",
@@ -1243,6 +1272,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 },
@@ -1466,7 +1589,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>(
@@ -1505,6 +1628,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
@@ -1514,7 +1667,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/contracts.service.ts b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
index 3d9152d11..c06e280dd 100644
--- a/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/contracts.service.ts
@@ -288,6 +288,13 @@ export const contractsService = {
   reject: (id: string, reason: string) =>
     postContract<Freight.IContract>(C.STAFF_REJECT(id), { reason }),
 
+  /**
+   * Cancel a contract outright. Terminal — unlike {@link suspend} there is no
+   * way back; a new contract with the same details must be submitted instead.
+   */
+  cancelByStaff: (id: string, reason: string) =>
+    postContract<Freight.IContract>(C.STAFF_CANCEL(id), { reason }),
+
   /** Freeze a signed contract. Reversible — see {@link resume}. */
   suspend: (id: string, reason: string) =>
     postContract<Freight.IContract>(C.SUSPEND(id), { reason }),
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 f983baf15..c14569d5a 100644
--- a/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/trainScheduling.service.ts
@@ -546,7 +546,12 @@ export const trainSchedulingService = {
 
   cancelRemainingWagons: async (
     bookingId: string,
-    payload: { scheduleId: string; reason: string; edrFault?: boolean },
+    payload: {
+      scheduleId: string;
+      reason: string;
+      edrFault?: boolean;
+      wagonAllocationIds?: string[];
+    },
   ): Promise<unknown> => {
     const response = await client.post(
       URL_CONSTANTS.TRAIN_SCHEDULING.CANCEL_REMAINING_WAGONS(bookingId),
diff --git a/apps/edr-freight-web/backoffice/src/services/transit-agents.service.ts b/apps/edr-freight-web/backoffice/src/services/transit-agents.service.ts
index bee743920..96687dc67 100644
--- a/apps/edr-freight-web/backoffice/src/services/transit-agents.service.ts
+++ b/apps/edr-freight-web/backoffice/src/services/transit-agents.service.ts
@@ -1,5 +1,6 @@
-import { api } from "../auth/http";
+import { api as apiClient } from "../auth/http";
 import { URL_CONSTANTS } from "../constants/URLS";
+import type { ResetChannel } from "../types/shippingLineCompany";
 
 export interface TransitAgent {
   id: string;
@@ -7,14 +8,53 @@ export interface TransitAgent {
   validFrom: string;
   validTo: string;
   isActive: boolean;
+  /** Null on every agent that exists only as a GL-assignable roster entry. */
+  email?: string | null;
+  phoneNumber?: string | null;
+  /** True once an IAM account backs the agent — i.e. it can sign in. */
+  hasAccount?: boolean;
+}
+
+export interface InviteTransitAgentDto {
+  email: string;
+  phoneNumber?: string;
+  username?: string;
+}
+
+/** What the API reports back about an activation send. */
+export interface ActivationSendResult {
+  maskedTarget: string;
+  channel: string;
+  expiresAt: string;
 }
 
 export const transitAgentsService = {
   /** Active + currently inside its validity window — the assignment dropdown. */
   async listAssignable() {
-    const response = await api.get<TransitAgent[]>(
+    const response = await apiClient.get<TransitAgent[]>(
       URL_CONSTANTS.RULE_ENGINE.TRANSIT_AGENTS_ASSIGNABLE,
     );
     return response.data;
   },
+
+  /**
+   * Create the portal account for an agent that has none and send its
+   * activation link. Separate from the rule-engine CRUD update because it mints
+   * an IAM user, which a field edit must never do implicitly.
+   */
+  async invite(id: string, dto: InviteTransitAgentDto) {
+    const response = await apiClient.post<{
+      agent: TransitAgent;
+      activationSentTo: string | null;
+    }>(URL_CONSTANTS.RULE_ENGINE.TRANSIT_AGENT_INVITE(id), dto);
+    return response.data;
+  },
+
+  async resendActivation(id: string, channel: ResetChannel) {
+    const response = await apiClient.post<ActivationSendResult>(
+      URL_CONSTANTS.RULE_ENGINE.TRANSIT_AGENT_RESEND_ACTIVATION(id),
+      { channel },
+    );
+    return 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/booking.ts b/apps/edr-freight-web/backoffice/src/types/booking.ts
index 287b41c83..2756d3155 100644
--- a/apps/edr-freight-web/backoffice/src/types/booking.ts
+++ b/apps/edr-freight-web/backoffice/src/types/booking.ts
@@ -201,6 +201,10 @@ export interface BookingDetail {
   cargoTotalWeightVgm: number;
   /** Break-bulk (PER_ITEM) only: real total tons — cargoTotalWeightVgm then holds the item count. */
   bulkTotalWeightTons?: number | null;
+  /** NUMBER_OF_WAGONS bulk only: the wagon count the customer booked. */
+  bulkRequestedWagons?: number | null;
+  /** NUMBER_OF_WAGONS bulk only: informational item count entered with the weight. */
+  bulkItemCount?: number | null;
   isHazardous: boolean;
   isReefer?: boolean;
   consolidationPartnerId?: string | null;
@@ -264,7 +268,9 @@ export interface BookingDetail {
   originYard?: BookingNamedRef;
   destinationYard?: BookingNamedRef;
   serviceType?: BookingNamedRef & { code?: string; includesCustoms?: boolean; includesFirstMile?: boolean; includesLastMile?: boolean };
-  cargoType?: BookingNamedRef;
+  cargoType?: BookingNamedRef & {
+    unitOfMeasure?: "PER_TON" | "PER_ITEM" | "NUMBER_OF_WAGONS" | null;
+  };
   shippingLine?: BookingNamedRef;
   bookingContainers?: BookingContainerLine[];
   reviewNotes?: BookingReviewNote[];
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/App.tsx b/apps/edr-freight-web/portal/src/App.tsx
index 8ab2f60d1..f224b3959 100644
--- a/apps/edr-freight-web/portal/src/App.tsx
+++ b/apps/edr-freight-web/portal/src/App.tsx
@@ -3,6 +3,7 @@ import { useDisclosure } from "@mantine/hooks";
 import {
   Home,
   Layers,
+  LayoutDashboard,
   LifeBuoy,
   Loader2,
   // MapPin,
@@ -68,6 +69,10 @@ import {
   ShippingLineInvoicesPage,
   ShippingLineSettingsPage,
 } from "./pages/shipping-line";
+import {
+  TransitAgentBookingsPage,
+  TransitAgentOverviewPage,
+} from "./pages/transit-agent";
 import FaqPage from "./pages/support/FaqPage";
 import HelpPage from "./pages/support/HelpPage";
 import PrivacyPolicyPage from "./pages/support/PrivacyPolicyPage";
@@ -143,15 +148,15 @@ function isOnboardingAllowedPath(pathname: string): boolean {
  * captured, so there is nothing for them to onboard — they go straight to home.
  */
 function OnboardingGate() {
-  const { company, onboardingCompleted, isShippingLine } = useAuth();
+  const { company, onboardingCompleted, isShippingLine, isTransitAgent } =
+    useAuth();
   const location = useLocation();
 
-  // Keyed off a positive shipping-line identification, never off "no company":
-  // that is also true mid-fetch and on error, which would let customers slip
-  // past onboarding whenever the request failed.
-  const needsOnboarding = isShippingLine
-    ? false
-    : !company || !onboardingCompleted;
+  // Keyed off a positive shipping-line / transit-agent identification, never
+  // off "no company": that is also true mid-fetch and on error, which would let
+  // customers slip past onboarding whenever the request failed.
+  const needsOnboarding =
+    isShippingLine || isTransitAgent ? false : !company || !onboardingCompleted;
   const allowedHere = isOnboardingAllowedPath(location.pathname);
 
   // Open by default while onboarding is pending (covers the login case).
@@ -199,13 +204,14 @@ function OnboardingGate() {
  * contract/company-shaped page that has no meaning for it.
  */
 function RequireCustomer() {
-  const { isShippingLine, customerQuery } = useAuth();
+  const { isShippingLine, isTransitAgent, customerQuery } = useAuth();
 
   // RequireCompany already awaits this query, but guard anyway: a refetch can
   // flip `isPending` back on, and redirecting on a half-loaded account would
   // throw the user into the wrong app.
   if (customerQuery.isPending) return <FullScreenSpinner />;
   if (isShippingLine) return <Navigate to="/shipping-line" replace />;
+  if (isTransitAgent) return <Navigate to="/transit-agent" replace />;
   return <Outlet />;
 }
 
@@ -218,6 +224,15 @@ function RequireShippingLine() {
   return <Outlet />;
 }
 
+/** Transit-agent routes, closed to every other account kind. */
+function RequireTransitAgent() {
+  const { isTransitAgent, customerQuery } = useAuth();
+
+  if (customerQuery.isPending) return <FullScreenSpinner />;
+  if (!isTransitAgent) return <Navigate to="/portal" replace />;
+  return <Outlet />;
+}
+
 /**
  * Where a signed-in account belongs. Shipping lines and customers have separate
  * apps, so every "you're already logged in" redirect has to pick between them.
@@ -225,11 +240,15 @@ function RequireShippingLine() {
  * still in flight, which would land a shipping line on the customer home first.
  */
 function useHomeRoute(): { ready: boolean; href: string } {
-  const { isShippingLine, customerQuery } = useAuth();
+  const { isShippingLine, isTransitAgent, customerQuery } = useAuth();
 
   return {
     ready: !customerQuery.isPending,
-    href: isShippingLine ? "/shipping-line" : "/portal",
+    href: isShippingLine
+      ? "/shipping-line"
+      : isTransitAgent
+        ? "/transit-agent"
+        : "/portal",
   };
 }
 
@@ -326,6 +345,24 @@ const shippingLineSidebarItems: SidebarItem[] = [
   },
 ];
 
+/**
+ * Sidebar for transit agents. Two entries only — the rest of the portal
+ * (contracts, invoices, settings, support) is company-scoped and has no meaning
+ * for an agent, so nothing is filtered in from the other lists.
+ */
+const transitAgentSidebarItems: SidebarItem[] = [
+  {
+    label: "Overview",
+    href: "/transit-agent",
+    icon: <LayoutDashboard size={18} />,
+  },
+  {
+    label: "Bookings",
+    href: "/transit-agent/bookings",
+    icon: <Package size={18} />,
+  },
+];
+
 const App = () => {
   const navigate = useNavigate();
   const location = useLocation();
@@ -337,6 +374,7 @@ const App = () => {
     reapplyProfile,
     isAuthenticated,
     isShippingLine,
+    isTransitAgent,
   } = useAuth();
 
   // Attribute replays and exceptions to the signed-in user (id/org only).
@@ -478,6 +516,39 @@ const App = () => {
               </Route>
             )}
 
+            {/* Transit-agent app. Two pages, both empty for now, behind their
+              own layout — there is no support widget because the chat is
+              company-scoped and an agent has no company, exactly as for a
+              shipping line. */}
+            {isTransitAgent && (
+              <Route element={<RequireTransitAgent />}>
+                <Route
+                  element={
+                    <AppLayout
+                      title="EDR Freight"
+                      sidebarItems={transitAgentSidebarItems}
+                      activeHref={location.pathname}
+                      onNavigate={navigate}
+                      userName={displayName}
+                      userEmail={userEmail}
+                      showSupportWidget={false}
+                    >
+                      <Outlet />
+                    </AppLayout>
+                  }
+                >
+                  <Route
+                    path="/transit-agent"
+                    element={<TransitAgentOverviewPage />}
+                  />
+                  <Route
+                    path="/transit-agent/bookings"
+                    element={<TransitAgentBookingsPage />}
+                  />
+                </Route>
+              </Route>
+            )}
+
             {/* Customer app — unchanged. */}
             <Route element={<RequireCustomer />}>
               <Route
diff --git a/apps/edr-freight-web/portal/src/hooks/useAuth.ts b/apps/edr-freight-web/portal/src/hooks/useAuth.ts
index 518d9dd35..e9ad1753c 100644
--- a/apps/edr-freight-web/portal/src/hooks/useAuth.ts
+++ b/apps/edr-freight-web/portal/src/hooks/useAuth.ts
@@ -6,6 +6,7 @@ import type {
 import {
   companiesService,
   isShippingLineAccount,
+  isTransitAgentAccount,
 } from "@/services/companies.service";
 import type {
   LoginPayload,
@@ -184,10 +185,21 @@ const useAuth = () => {
   const isShippingLine = isShippingLineAccount(accountInfo);
   const shippingLine = isShippingLine ? accountInfo : null;
 
-  // Every customer-shaped field below is null/empty for a shipping line.
-  const companyInfo = isShippingLine
-    ? null
-    : (accountInfo as CompanyInfoResponse | null);
+  /**
+   * Transit agents share the portal with customers and shipping lines but have
+   * no company, no external profile and no onboarding. Identified positively
+   * from the backend's discriminator, for the same reason as the shipping line
+   * above — never from "company is missing".
+   */
+  const isTransitAgent = isTransitAgentAccount(accountInfo);
+  const transitAgent = isTransitAgent ? accountInfo : null;
+
+  // Every customer-shaped field below is null/empty for a shipping line and for
+  // a transit agent alike.
+  const companyInfo =
+    isShippingLine || isTransitAgent
+      ? null
+      : (accountInfo as CompanyInfoResponse | null);
   const companyType = companyInfo?.company?.type ?? null;
   const companyStatus = companyInfo?.company?.status ?? null;
   // A company can create bookings only once an admin has approved it (active).
@@ -314,6 +326,8 @@ const useAuth = () => {
     onboardingStep,
     isShippingLine,
     shippingLine,
+    isTransitAgent,
+    transitAgent,
     createProfile,
     reapplyProfile,
     login,
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
index 46c19ea7a..25f601628 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/DocumentsTab.tsx
@@ -27,6 +27,25 @@ import { ClearanceUploadedDocumentsPanel } from "@/components/contracts/Clearanc
 
 import toast from "react-hot-toast";
 
+/**
+ * A `responseType: "blob"` request delivers its JSON error body as a Blob, so
+ * reading `error.message` gives "Request failed with status code 400" instead
+ * of the reason. Read the blob back before falling back.
+ */
+async function downloadErrorMessage(error: unknown, fallback: string): Promise<string> {
+  const data = (error as { response?: { data?: unknown } })?.response?.data;
+  if (data instanceof Blob) {
+    try {
+      const parsed = JSON.parse(await data.text()) as { message?: unknown };
+      if (parsed?.message) return String(parsed.message);
+    } catch {
+      /* not JSON — fall through */
+    }
+  }
+  return error instanceof Error ? error.message : fallback;
+}
+
+
 import { bookingsService } from "@/services/bookings.service";
 import type { EmptyContainerReturn } from "@/services/bookings.service";
 import { saveBlob } from "@/utils/download";
@@ -308,6 +327,25 @@ export function DocumentsTab({ booking }: { booking: Freight.IBooking }) {
 
   // One-click warehouse-document bundle: GRN + gate clearance + handover.
   const [bundleBusy, setBundleBusy] = useState(false);
+
+  // The carriage acceptance sheet is its own document, not warehouse paperwork:
+  // direct truck-to-train cargo never sees a warehouse, and this sheet IS its
+  // handover record. Hiding it inside the warehouse bundle made it unfindable.
+  const [casBusy, setCasBusy] = useState(false);
+  const downloadCarriageAcceptance = async () => {
+    setCasBusy(true);
+    const ref = booking.reference ?? booking.id;
+    try {
+      const blob = await bookingsService.downloadCarriageAcceptanceSheet(booking.id);
+      saveBlob(blob, `carriage-acceptance-${ref}.pdf`);
+    } catch (error) {
+      toast.error(
+        await downloadErrorMessage(error, "Carriage acceptance sheet is not available yet."),
+      );
+    } finally {
+      setCasBusy(false);
+    }
+  };
   const downloadWarehouseDocuments = async () => {
     setBundleBusy(true);
     const ref = booking.reference ?? booking.id;
@@ -654,6 +692,24 @@ export function DocumentsTab({ booking }: { booking: Freight.IBooking }) {
         </SectionCard>
       )}
 
+      {/* ── Carriage acceptance sheet (its own document) ────────────────── */}
+      <SectionCard>
+        <CardTitle>Carriage acceptance sheet</CardTitle>
+        <Text fz="12.5px" c="dimmed" mt={4} mb="sm">
+          The record of the cargo EDR has accepted for carriage, listing each wagon and the
+          containers on it, and marking which have been loaded.
+        </Text>
+        <Button
+          leftSection={<Download size={16} />}
+          color="edr-green"
+          variant="light"
+          loading={casBusy}
+          onClick={downloadCarriageAcceptance}
+        >
+          Download sheet
+        </Button>
+      </SectionCard>
+
       {/* ── Warehouse documents (one-click bundle) ──────────────────────── */}
       <SectionCard>
         <CardTitle>Warehouse documents</CardTitle>
diff --git a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WagonsTab.tsx b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WagonsTab.tsx
index 345028ad0..2dd880c7b 100644
--- a/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WagonsTab.tsx
+++ b/apps/edr-freight-web/portal/src/pages/bookings/BookingDetailPage/components/WagonsTab.tsx
@@ -235,9 +235,9 @@ function ConsistStrip({ wagons }: { wagons: BookingWagonAllocation[] }) {
             LOCO
           </Text>
         </Box>
-        {wagons.map((w) => (
+        {wagons.map((w, i) => (
           <Tooltip
-            key={w.sequenceNo}
+            key={w.allocationId ?? w.sequenceNo}
             label={`${w.wagonNumber ?? "Unassigned"} · ${w.wagonType ?? "—"} · ${
               STATUS_TONES[w.status]?.label ?? w.status
             }`}
@@ -257,7 +257,7 @@ function ConsistStrip({ wagons }: { wagons: BookingWagonAllocation[] }) {
               }}
             >
               <Text fz={10} fw={700} c="#6B7C8E">
-                W{w.sequenceNo}
+                W{i + 1}
               </Text>
               <Text fz={11.5} fw={800} c="#10202F" style={{ fontFamily: "monospace" }}>
                 {w.wagonNumber ?? "—"}
@@ -302,12 +302,21 @@ const th = { color: "#9AA8B5", fontSize: 11 } as const;
 
 function WagonCard({
   wagon,
+  displayNo,
   selectable,
   selected,
   shared,
   onToggle,
 }: {
   wagon: BookingWagonAllocation;
+  /**
+   * 1-based position in THIS booking's wagon list — what the customer sees.
+   * Deliberately not `sequenceNo`, which is the wagon's slot in the shared
+   * train set and so starts wherever the previous booking left off (and
+   * leaves holes when wagons are cancelled). Cancellation keys off
+   * `allocationId`, so this number is display-only.
+   */
+  displayNo: number;
   selectable?: boolean;
   selected?: boolean;
   /** Shared consolidation wagon — not selectable for cancellation. */
@@ -333,7 +342,7 @@ function WagonCard({
               checked={!!selected}
               onChange={onToggle}
               color="orange"
-              aria-label={`Select wagon ${wagon.sequenceNo} for cancellation`}
+              aria-label={`Select wagon ${displayNo} for cancellation`}
             />
           )}
           <Box
@@ -354,7 +363,7 @@ function WagonCard({
               WAGON
             </Text>
             <Text fz={15} fw={800} lh={1.2}>
-              {wagon.sequenceNo}
+              {displayNo}
             </Text>
           </Box>
           <Box>
@@ -727,7 +736,7 @@ export function WagonsTab({
       <CancelledWagonsSection rows={ownCancellations} />
 
       <SimpleGrid cols={{ base: 1, md: 2 }} spacing={24}>
-        {wagons.map((w) => {
+        {wagons.map((w, i) => {
           // The shared consolidation wagon carries this booking's lone 20ft —
           // its other half belongs to the partner booking, so it can never be
           // cancelled on its own (the server rejects it too).
@@ -740,6 +749,7 @@ export function WagonsTab({
             <WagonCard
               key={w.allocationId ?? w.sequenceNo}
               wagon={w}
+              displayNo={i + 1}
               shared={isSharedWagon}
               selectable={
                 canSelect &&
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-freight-web/portal/src/pages/transit-agent/TransitAgentBookingsPage.tsx b/apps/edr-freight-web/portal/src/pages/transit-agent/TransitAgentBookingsPage.tsx
new file mode 100644
index 000000000..4e86a2de0
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/transit-agent/TransitAgentBookingsPage.tsx
@@ -0,0 +1,454 @@
+import {
+  Alert,
+  Box,
+  Button,
+  Card,
+  Center,
+  Group,
+  Loader,
+  Pagination,
+  Select,
+  SimpleGrid,
+  Stack,
+  Table,
+  Text,
+  TextInput,
+  Title,
+  Tooltip,
+} from "@mantine/core";
+import { useDebouncedValue } from "@mantine/hooks";
+import { keepPreviousData, useQuery } from "@tanstack/react-query";
+import {
+  AlertCircle,
+  CheckCircle2,
+  Clock3,
+  FileText,
+  Lock,
+  Paperclip,
+  Search,
+  Train,
+  X,
+} from "lucide-react";
+import { useEffect, useMemo, useState } from "react";
+
+import { cv } from "@/pages/MyPortalPage/constants";
+import TransitAgentDocumentsModal from "@/pages/transit-agent/TransitAgentDocumentsModal";
+import {
+  transitAssignmentsService,
+  type TransitAssignment,
+  type TransitAssignmentStatus,
+} from "@/services/transit-assignments.service";
+
+const PAGE_SIZE = 8;
+
+const PAGE_SIZE_OPTIONS = [
+  { value: "8", label: "8 / page" },
+  { value: "20", label: "20 / page" },
+  { value: "50", label: "50 / page" },
+];
+
+/** Status pills use the portal's soft-tint / strong-ink pairs, not raw Mantine colours. */
+const STATUS_META: Record<
+  TransitAssignmentStatus,
+  { label: string; bg: string; fg: string }
+> = {
+  NOT_STARTED: {
+    label: "Not started",
+    bg: "edr-slate-soft",
+    fg: "edr-slate",
+  },
+  IN_PROGRESS: { label: "In progress", bg: "edr-blue-soft", fg: "edr-blue" },
+  FINISHED: { label: "Finished", bg: "edr-soft", fg: "edr-green.7" },
+};
+
+const STATUS_OPTIONS = [
+  { value: "NOT_STARTED", label: "Not started" },
+  { value: "IN_PROGRESS", label: "In progress" },
+  { value: "FINISHED", label: "Finished" },
+];
+
+const SHIPMENT_OPTIONS = [
+  { value: "DISPATCHED", label: "Dispatched (in transit)" },
+  { value: "SCHEDULED", label: "Scheduled" },
+];
+
+/** Minutes as "5h 30m" — the raw integer is unreadable in a grid. */
+function formatMinutes(minutes: number | null): string {
+  if (minutes === null) return "—";
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return hours ? `${hours}h ${rest}m` : `${rest}m`;
+}
+
+/** Sentence-cases a SCREAMING_SNAKE enum for display. */
+function humanize(value?: string | null): string {
+  if (!value) return "—";
+  const spaced = value.toLowerCase().replace(/_/g, " ");
+  return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+}
+
+function SummaryTile({
+  icon,
+  label,
+  value,
+  soft,
+}: {
+  icon: React.ReactNode;
+  label: string;
+  value: number | string;
+  soft: string;
+}) {
+  return (
+    <Box className="rounded-[20px] border border-edr-border bg-edr-card" p={16}>
+      <Group gap={12} wrap="nowrap">
+        <Box
+          className="flex size-10 shrink-0 items-center justify-center rounded-xl"
+          style={{ background: cv(soft) }}
+        >
+          {icon}
+        </Box>
+        <Box className="min-w-0">
+          <Text
+            fz={22}
+            fw={800}
+            lh={1.1}
+            c="edr-text"
+            className="tracking-tight"
+          >
+            {value}
+          </Text>
+          <Text fz={11} fw={600} c="edr-muted" truncate>
+            {label}
+          </Text>
+        </Box>
+      </Group>
+    </Box>
+  );
+}
+
+/**
+ * The transit agent's work list: every booking assigned to them, with the
+ * document action for each.
+ *
+ * Filtering and paging are server-side — the roster grows without bound, so
+ * neither can depend on holding every row in the browser. Uploading is gated on
+ * the API's own `canUploadDocuments`, never re-derived here, so a row's action
+ * cannot promise something the server will reject.
+ */
+export default function TransitAgentBookingsPage() {
+  const [active, setActive] = useState<TransitAssignment | null>(null);
+  const [search, setSearch] = useState("");
+  const [debouncedSearch] = useDebouncedValue(search, 300);
+  const [status, setStatus] = useState<string | null>(null);
+  const [shipment, setShipment] = useState<string | null>(null);
+  const [page, setPage] = useState(1);
+  const [pageSize, setPageSize] = useState(PAGE_SIZE);
+
+  // Any filter change invalidates the current page number: staying on page 3 of
+  // a freshly narrowed result set shows an empty table.
+  useEffect(() => {
+    setPage(1);
+  }, [debouncedSearch, status, shipment, pageSize]);
+
+  const query = useQuery({
+    queryKey: [
+      "transit-assignments",
+      { search: debouncedSearch, status, shipment, page, pageSize },
+    ],
+    queryFn: () =>
+      transitAssignmentsService.list({
+        search: debouncedSearch || undefined,
+        status: (status as TransitAssignmentStatus) ?? undefined,
+        schedulingStatus: shipment ?? undefined,
+        page,
+        pageSize,
+      }),
+    // Keeps the previous page visible while the next one loads, so paging does
+    // not flash an empty table.
+    placeholderData: keepPreviousData,
+  });
+
+  const items = query.data?.items ?? [];
+  const meta = query.data?.meta;
+  const hasFilters = !!(debouncedSearch || status || shipment);
+
+  // Counts describe the CURRENT PAGE, and say so — deriving totals from a
+  // paginated slice would quietly under-report the agent's real workload.
+  const pageCounts = useMemo(
+    () => ({
+      open: items.filter((a) => a.status !== "FINISHED").length,
+      uploadable: items.filter((a) => a.canUploadDocuments).length,
+      documents: items.reduce((sum, a) => sum + (a.files?.length ?? 0), 0),
+    }),
+    [items],
+  );
+
+  const clearFilters = () => {
+    setSearch("");
+    setStatus(null);
+    setShipment(null);
+  };
+
+  return (
+    <Stack gap="lg" p={{ base: 16, sm: 24, lg: 32 }}>
+      <Stack gap={4}>
+        <Title order={2}>Bookings</Title>
+        <Text fz={13} c="edr-muted">
+          Shipments assigned to you for transit. Documents can be uploaded once
+          a booking is dispatched, and are locked when you finish it.
+        </Text>
+      </Stack>
+
+      <SimpleGrid cols={{ base: 1, xs: 2, sm: 4 }} spacing="sm">
+        <SummaryTile
+          icon={<Train size={18} color={cv("edr-blue")} strokeWidth={2} />}
+          label={meta ? "Assigned to you" : "Assigned"}
+          value={meta?.total ?? "—"}
+          soft="edr-blue-soft"
+        />
+        <SummaryTile
+          icon={
+            <Clock3 size={18} color={cv("edr-amber-text")} strokeWidth={2} />
+          }
+          label="Open on this page"
+          value={pageCounts.open}
+          soft="edr-amber-soft"
+        />
+        <SummaryTile
+          icon={
+            <CheckCircle2 size={18} color={cv("edr-green.7")} strokeWidth={2} />
+          }
+          label="Ready for documents"
+          value={pageCounts.uploadable}
+          soft="edr-soft"
+        />
+        <SummaryTile
+          icon={<Paperclip size={18} color={cv("edr-slate")} strokeWidth={2} />}
+          label="Documents on this page"
+          value={pageCounts.documents}
+          soft="edr-slate-soft"
+        />
+      </SimpleGrid>
+
+      <Card withBorder radius="md" p="md">
+        <Group gap="sm" align="flex-end" wrap="wrap">
+          <TextInput
+            flex="1 1 240px"
+            label="Search"
+            placeholder="Booking reference or customer"
+            leftSection={<Search size={15} />}
+            value={search}
+            onChange={(e) => setSearch(e.currentTarget.value)}
+          />
+          <Select
+            w={190}
+            label="My status"
+            placeholder="Any"
+            data={STATUS_OPTIONS}
+            value={status}
+            onChange={setStatus}
+            clearable
+          />
+          <Select
+            w={210}
+            label="Shipment"
+            placeholder="Any"
+            data={SHIPMENT_OPTIONS}
+            value={shipment}
+            onChange={setShipment}
+            clearable
+          />
+          {hasFilters ? (
+            <Button
+              variant="subtle"
+              color="edr-slate"
+              leftSection={<X size={15} />}
+              onClick={clearFilters}
+            >
+              Clear
+            </Button>
+          ) : null}
+        </Group>
+      </Card>
+
+      {query.isPending ? (
+        <Center py="xl">
+          <Loader size="sm" color="edr-green" />
+        </Center>
+      ) : query.isError ? (
+        <Alert color="red" variant="light" icon={<AlertCircle size={16} />}>
+          {(query.error as Error).message}
+        </Alert>
+      ) : items.length === 0 ? (
+        <Card withBorder radius="md" py={64}>
+          <Stack align="center" gap="xs">
+            <FileText size={28} opacity={0.4} />
+            <Text fz={13} c="edr-muted">
+              {hasFilters
+                ? "No bookings match these filters."
+                : "No bookings have been assigned to you yet."}
+            </Text>
+            {hasFilters ? (
+              <Button variant="subtle" size="compact-sm" onClick={clearFilters}>
+                Clear filters
+              </Button>
+            ) : null}
+          </Stack>
+        </Card>
+      ) : (
+        <Card withBorder radius="md" p={0}>
+          <Table.ScrollContainer minWidth={880}>
+            <Table striped highlightOnHover verticalSpacing="sm">
+              <Table.Thead>
+                <Table.Tr>
+                  <Table.Th>Booking</Table.Th>
+                  <Table.Th>Customer</Table.Th>
+                  <Table.Th>Shipment</Table.Th>
+                  <Table.Th>My status</Table.Th>
+                  <Table.Th ta="center">Docs</Table.Th>
+                  <Table.Th>Time after arrival</Table.Th>
+                  <Table.Th />
+                </Table.Tr>
+              </Table.Thead>
+              <Table.Tbody>
+                {items.map((assignment) => {
+                  const statusMeta = STATUS_META[assignment.status];
+                  const docCount = assignment.files?.length ?? 0;
+                  const locked = !assignment.canUploadDocuments;
+                  return (
+                    <Table.Tr key={assignment.id}>
+                      <Table.Td>
+                        <Text size="sm" fw={600}>
+                          {assignment.booking?.reference ?? "—"}
+                        </Text>
+                      </Table.Td>
+                      <Table.Td style={{ maxWidth: 260 }}>
+                        <Tooltip
+                          label={assignment.customerName ?? "—"}
+                          disabled={!assignment.customerName}
+                          multiline
+                          w={280}
+                        >
+                          <Text size="sm" truncate>
+                            {assignment.customerName ?? "—"}
+                          </Text>
+                        </Tooltip>
+                      </Table.Td>
+                      <Table.Td>
+                        <Group gap={7} wrap="nowrap">
+                          <Box
+                            className="size-1.5 shrink-0 rounded-full"
+                            style={{
+                              background:
+                                assignment.booking?.schedulingStatus ===
+                                "DISPATCHED"
+                                  ? cv("edr-blue-dot")
+                                  : cv("edr-step-idle"),
+                            }}
+                          />
+                          <Text fz={12} c="edr-text">
+                            {humanize(assignment.booking?.schedulingStatus)}
+                          </Text>
+                        </Group>
+                      </Table.Td>
+                      <Table.Td>
+                        <Box
+                          px={9}
+                          py={3}
+                          className="inline-flex w-fit rounded-full"
+                          style={{ background: cv(statusMeta.bg) }}
+                        >
+                          <Text
+                            fz={10}
+                            fw={700}
+                            style={{ color: cv(statusMeta.fg) }}
+                          >
+                            {statusMeta.label}
+                          </Text>
+                        </Box>
+                      </Table.Td>
+                      <Table.Td ta="center">
+                        <Text size="sm" c={docCount ? undefined : "dimmed"}>
+                          {docCount || "—"}
+                        </Text>
+                      </Table.Td>
+                      <Table.Td>
+                        <Text fz={13} c="edr-muted">
+                          {formatMinutes(assignment.timeAfterTrainArrives)}
+                        </Text>
+                      </Table.Td>
+                      <Table.Td>
+                        <Group justify="flex-end" wrap="nowrap">
+                          <Button
+                            size="compact-sm"
+                            variant={locked ? "subtle" : "light"}
+                            color={locked ? "gray" : undefined}
+                            leftSection={
+                              locked ? (
+                                <Lock size={13} />
+                              ) : (
+                                <FileText size={13} />
+                              )
+                            }
+                            onClick={() => setActive(assignment)}
+                          >
+                            {locked ? "View" : "Documents"}
+                          </Button>
+                        </Group>
+                      </Table.Td>
+                    </Table.Tr>
+                  );
+                })}
+              </Table.Tbody>
+            </Table>
+          </Table.ScrollContainer>
+
+          {meta ? (
+            <Group
+              justify="space-between"
+              p="md"
+              wrap="wrap"
+              gap="sm"
+              style={{
+                borderTop: "1px solid var(--mantine-color-default-border)",
+              }}
+            >
+              <Group gap="xs" wrap="nowrap">
+                <Text fz={13} c="edr-muted">
+                  Showing {(meta.page - 1) * meta.pageSize + 1}–
+                  {Math.min(meta.page * meta.pageSize, meta.total)} of{" "}
+                  {meta.total}
+                </Text>
+                <Select
+                  size="xs"
+                  w={110}
+                  aria-label="Rows per page"
+                  data={PAGE_SIZE_OPTIONS}
+                  value={String(pageSize)}
+                  onChange={(v) => setPageSize(Number(v) || PAGE_SIZE)}
+                  allowDeselect={false}
+                />
+              </Group>
+              {/* Rendered even on a single page: the control disappearing as
+                  the result set shrinks reads as a broken table rather than as
+                  "there is only one page". */}
+              <Pagination
+                size="sm"
+                value={meta.page}
+                total={meta.totalPages}
+                onChange={setPage}
+                withEdges
+                disabled={meta.totalPages <= 1}
+              />
+            </Group>
+          ) : null}
+        </Card>
+      )}
+
+      <TransitAgentDocumentsModal
+        assignment={active}
+        onClose={() => setActive(null)}
+      />
+    </Stack>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/transit-agent/TransitAgentDocumentsModal.tsx b/apps/edr-freight-web/portal/src/pages/transit-agent/TransitAgentDocumentsModal.tsx
new file mode 100644
index 000000000..36f76a243
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/transit-agent/TransitAgentDocumentsModal.tsx
@@ -0,0 +1,682 @@
+import {
+  ActionIcon,
+  Alert,
+  Badge,
+  Button,
+  Card,
+  Center,
+  FileButton,
+  Group,
+  Image,
+  Loader,
+  Modal,
+  Paper,
+  ScrollArea,
+  Stack,
+  Text,
+  Textarea,
+  TextInput,
+  ThemeIcon,
+  Tooltip,
+} from "@mantine/core";
+import { resolveViewerKind } from "@edr/ui-common";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import {
+  AlertCircle,
+  CheckCircle2,
+  Eye,
+  File as FileIcon,
+  FileSpreadsheet,
+  FileText,
+  Film,
+  ImageIcon,
+  Lock,
+  Trash2,
+  Upload,
+  X,
+} from "lucide-react";
+import { useEffect, useMemo, useRef, useState } from "react";
+
+import { useFileViewer } from "@/hooks/useFileViewer";
+import { fetchViewableFile, filesService } from "@/services/files.service";
+import {
+  transitAssignmentsService,
+  type TransitAssignment,
+  type TransitAssignmentFile,
+} from "@/services/transit-assignments.service";
+
+const formatBytes = (bytes: number): string =>
+  bytes >= 1024 * 1024
+    ? `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+    : `${Math.max(1, Math.round(bytes / 1024))} KB`;
+
+/** Icon + colour per viewer kind, so a file's type reads at a glance. */
+function kindVisuals(name: string, mimeType?: string | null) {
+  const kind = resolveViewerKind({ name, url: "", mimeType });
+  switch (kind) {
+    case "image":
+      return { icon: <ImageIcon size={18} />, color: "grape" };
+    case "pdf":
+      return { icon: <FileText size={18} />, color: "red" };
+    case "video":
+    case "audio":
+      return { icon: <Film size={18} />, color: "indigo" };
+    case "office":
+      return { icon: <FileSpreadsheet size={18} />, color: "teal" };
+    case "text":
+      return { icon: <FileText size={18} />, color: "blue" };
+    default:
+      return { icon: <FileIcon size={18} />, color: "gray" };
+  }
+}
+
+/** One already-uploaded document. */
+function UploadedFileCard({
+  file,
+  locked,
+  busy,
+  onView,
+  onRemove,
+}: {
+  file: TransitAssignmentFile;
+  locked: boolean;
+  busy: boolean;
+  onView: () => void;
+  onRemove: () => void;
+}) {
+  const visuals = kindVisuals(file.name, file.mimeType);
+  const isImage = (file.mimeType ?? "").startsWith("image/");
+  const [thumb, setThumb] = useState<string | null>(null);
+
+  /**
+   * Thumbnails are fetched through the API, not linked straight from `file.url`.
+   * That URL points at MinIO, which is not reachable from the browser, and
+   * `GET /api/files/:id` is JWT-guarded — so a bare `<img src>` gets either a
+   * DNS failure or a 401. The bytes come down the authenticated axios client
+   * and become a blob URL, revoked when the card unmounts.
+   */
+  useEffect(() => {
+    if (!isImage) return;
+    let objectUrl: string | null = null;
+    let cancelled = false;
+
+    void filesService
+      .download(file.id)
+      .then((blob) => {
+        if (cancelled) return;
+        objectUrl = URL.createObjectURL(blob);
+        setThumb(objectUrl);
+      })
+      // A failed thumbnail is not worth surfacing — the card falls back to its
+      // type icon and the preview button still reports any real error.
+      .catch(() => undefined);
+
+    return () => {
+      cancelled = true;
+      if (objectUrl) URL.revokeObjectURL(objectUrl);
+    };
+  }, [file.id, isImage]);
+
+  return (
+    <Paper withBorder radius="md" p="sm">
+      <Group gap="sm" wrap="nowrap" align="flex-start">
+        {isImage && thumb ? (
+          // A thumbnail is worth more than an icon for scanned paperwork, which
+          // is most of what gets filed here.
+          <Image
+            src={thumb}
+            alt={file.name}
+            w={44}
+            h={44}
+            radius="sm"
+            fit="cover"
+          />
+        ) : (
+          <ThemeIcon
+            variant="light"
+            color={visuals.color}
+            size={44}
+            radius="sm"
+          >
+            {visuals.icon}
+          </ThemeIcon>
+        )}
+
+        <Stack gap={2} style={{ flex: 1, minWidth: 0 }}>
+          <Tooltip label={file.title || file.name} openDelay={400}>
+            <Text size="sm" fw={500} truncate>
+              {file.title || file.name}
+            </Text>
+          </Tooltip>
+          <Text size="xs" c="dimmed">
+            {formatBytes(file.size)} ·{" "}
+            {new Date(file.uploadedAt).toLocaleString()}
+          </Text>
+          {file.uploadedByName ? (
+            <Text size="xs" c="dimmed" truncate>
+              by {file.uploadedByName}
+            </Text>
+          ) : null}
+        </Stack>
+
+        <Group gap={4} wrap="nowrap">
+          <Tooltip label="Preview">
+            <ActionIcon variant="subtle" onClick={onView}>
+              <Eye size={16} />
+            </ActionIcon>
+          </Tooltip>
+          {locked ? null : (
+            <Tooltip label="Remove">
+              <ActionIcon
+                variant="subtle"
+                color="red"
+                disabled={busy}
+                onClick={onRemove}
+              >
+                <Trash2 size={16} />
+              </ActionIcon>
+            </Tooltip>
+          )}
+        </Group>
+      </Group>
+    </Paper>
+  );
+}
+
+/** A file chosen but not yet uploaded: local preview plus the name to file it under. */
+function PendingFileCard({
+  file,
+  title,
+  previewUrl,
+  onTitleChange,
+  onView,
+  onRemove,
+  disabled,
+}: {
+  file: File;
+  title: string;
+  previewUrl: string;
+  onTitleChange: (title: string) => void;
+  onView: () => void;
+  onRemove: () => void;
+  disabled: boolean;
+}) {
+  const visuals = kindVisuals(file.name, file.type);
+  const isImage = file.type.startsWith("image/");
+
+  return (
+    <Paper withBorder radius="md" p="xs" bg="var(--mantine-color-blue-light)">
+      <Group gap="sm" wrap="nowrap">
+        {isImage ? (
+          <Image
+            src={previewUrl}
+            alt={file.name}
+            w={36}
+            h={36}
+            radius="sm"
+            fit="cover"
+          />
+        ) : (
+          <ThemeIcon
+            variant="light"
+            color={visuals.color}
+            size={36}
+            radius="sm"
+          >
+            {visuals.icon}
+          </ThemeIcon>
+        )}
+        <Stack gap={4} style={{ flex: 1, minWidth: 0 }}>
+          <TextInput
+            size="xs"
+            placeholder="Document name (optional)"
+            value={title}
+            disabled={disabled}
+            onChange={(e) => onTitleChange(e.currentTarget.value)}
+          />
+          <Text size="xs" c="dimmed" truncate>
+            {file.name} · {formatBytes(file.size)}
+          </Text>
+        </Stack>
+        <Group gap={2} wrap="nowrap">
+          <Tooltip label="Preview before uploading">
+            <ActionIcon variant="subtle" onClick={onView}>
+              <Eye size={15} />
+            </ActionIcon>
+          </Tooltip>
+          <Tooltip label="Remove from selection">
+            <ActionIcon
+              variant="subtle"
+              color="red"
+              disabled={disabled}
+              onClick={onRemove}
+            >
+              <X size={15} />
+            </ActionIcon>
+          </Tooltip>
+        </Group>
+      </Group>
+    </Paper>
+  );
+}
+
+/**
+ * Documents for one transit assignment: what has been filed, and what is about
+ * to be.
+ *
+ * Uploading is gated on the server by two rules — the booking must be
+ * dispatched, and the assignment must not be finished. Rather than
+ * re-implementing them here, the modal reads the server's own
+ * `canUploadDocuments`, so the disabled state can never disagree with what the
+ * API would accept.
+ */
+export default function TransitAgentDocumentsModal({
+  assignment,
+  onClose,
+}: {
+  assignment: TransitAssignment | null;
+  onClose: () => void;
+}) {
+  const queryClient = useQueryClient();
+  const { view, viewer } = useFileViewer();
+  /**
+   * Files chosen but not yet uploaded, each with the name the agent gives it.
+   * Kept as objects rather than two parallel arrays so removing one entry
+   * cannot desynchronise a file from its title.
+   */
+  const [pending, setPending] = useState<{ file: File; title: string }[]>([]);
+  const [note, setNote] = useState("");
+
+  /**
+   * Object URLs for the staged files, keyed by File identity.
+   *
+   * Keyed rather than rebuilt as an array: removing one file from the selection
+   * would otherwise re-create every URL and revoke the old ones, which kills the
+   * preview of a DIFFERENT file if the viewer happens to be open on it. Only
+   * URLs whose file has actually left the selection are revoked.
+   */
+  const previewsRef = useRef(new Map<File, string>());
+  const previews = useMemo(() => {
+    const next = new Map<File, string>();
+    for (const { file } of pending) {
+      next.set(
+        file,
+        previewsRef.current.get(file) ?? URL.createObjectURL(file),
+      );
+    }
+    for (const [file, url] of previewsRef.current) {
+      if (!next.has(file)) URL.revokeObjectURL(url);
+    }
+    previewsRef.current = next;
+    return next;
+  }, [pending]);
+
+  // Last resort: revoke whatever is still held when the modal unmounts.
+  useEffect(
+    () => () => {
+      for (const url of previewsRef.current.values()) URL.revokeObjectURL(url);
+      previewsRef.current = new Map();
+    },
+    [],
+  );
+
+  // Each assignment opens a fresh sheet — files staged for one must not follow
+  // the modal onto another.
+  useEffect(() => {
+    setPending([]);
+    setNote(assignment?.note ?? "");
+  }, [assignment?.id, assignment?.note]);
+
+  const detailQuery = useQuery({
+    queryKey: ["transit-assignment", assignment?.id],
+    queryFn: () => transitAssignmentsService.getById(assignment!.id),
+    enabled: assignment !== null,
+  });
+
+  const detail = detailQuery.data ?? assignment;
+  const locked = !detail?.canUploadDocuments;
+  const isFinished = detail?.status === "FINISHED";
+
+  const invalidate = async () => {
+    await Promise.all([
+      queryClient.invalidateQueries({ queryKey: ["transit-assignments"] }),
+      queryClient.invalidateQueries({
+        queryKey: ["transit-assignment", assignment?.id],
+      }),
+    ]);
+  };
+
+  const uploadMutation = useMutation({
+    mutationFn: () =>
+      transitAssignmentsService.uploadFiles(assignment!.id, pending),
+    onSuccess: async () => {
+      setPending([]);
+      await invalidate();
+    },
+  });
+
+  /**
+   * Save = persist everything the agent has entered, without closing the work.
+   *
+   * Staged files are uploaded FIRST, then the note is saved: a Save that left
+   * the chosen files sitting in the browser would look like it had stored them,
+   * and they would be silently lost on close. The status only ever moves to
+   * IN_PROGRESS here — finishing is a separate, deliberate action.
+   */
+  const saveMutation = useMutation({
+    mutationFn: async () => {
+      if (pending.length > 0) {
+        await transitAssignmentsService.uploadFiles(assignment!.id, pending);
+      }
+      return transitAssignmentsService.submit(assignment!.id, {
+        finish: false,
+        note,
+      });
+    },
+    onSuccess: async () => {
+      setPending([]);
+      await invalidate();
+    },
+  });
+
+  const removeMutation = useMutation({
+    mutationFn: (fileId: string) =>
+      transitAssignmentsService.removeFile(assignment!.id, fileId),
+    onSuccess: invalidate,
+  });
+
+  // Save keeps the assignment open; finish closes it AND locks the documents,
+  // which is why the button asks first.
+  const finishMutation = useMutation({
+    mutationFn: async () => {
+      // Flush anything still staged before closing: finishing locks uploads, so
+      // a file left behind here could never be filed afterwards.
+      if (pending.length > 0) {
+        await transitAssignmentsService.uploadFiles(assignment!.id, pending);
+      }
+      return transitAssignmentsService.submit(assignment!.id, {
+        finish: true,
+        note,
+      });
+    },
+    onSuccess: async () => {
+      setPending([]);
+      await invalidate();
+      onClose();
+    },
+  });
+
+  /**
+   * Open a stored document in the viewer.
+   *
+   * The bytes are fetched through the authenticated API rather than linked from
+   * `file.url`: that column holds the MinIO object URL, which the browser
+   * cannot reach, and `GET /api/files/:id` requires the Bearer token that a
+   * raw `<iframe>`/`<img>` load would not carry.
+   */
+  const [viewerError, setViewerError] = useState<string | null>(null);
+  const openUploaded = (file: TransitAssignmentFile) => {
+    setViewerError(null);
+    void fetchViewableFile(file.id, file.title || file.name)
+      .then((viewable) =>
+        view({ ...viewable, mimeType: viewable.mimeType ?? file.mimeType }),
+      )
+      .catch((error: Error) =>
+        setViewerError(error.message || "Could not open this document."),
+      );
+  };
+
+  const files = detail?.files ?? [];
+  const busy =
+    uploadMutation.isPending ||
+    removeMutation.isPending ||
+    saveMutation.isPending ||
+    finishMutation.isPending;
+
+  return (
+    <>
+      <Modal
+        opened={assignment !== null}
+        onClose={onClose}
+        title={
+          <Group gap="xs">
+            <Text fw={600}>Documents</Text>
+            <Text c="dimmed">{detail?.booking?.reference ?? ""}</Text>
+          </Group>
+        }
+        size="lg"
+        centered
+      >
+        {detailQuery.isPending ? (
+          <Center py="xl">
+            <Loader size="sm" />
+          </Center>
+        ) : (
+          <Stack gap="md">
+            {detail?.customerName ? (
+              <Text size="sm" c="dimmed">
+                {detail.customerName}
+              </Text>
+            ) : null}
+
+            {isFinished ? (
+              <Alert
+                color="teal"
+                variant="light"
+                icon={<CheckCircle2 size={16} />}
+              >
+                This assignment is finished. Its documents are locked and can no
+                longer be added to or removed.
+              </Alert>
+            ) : locked ? (
+              <Alert
+                color="yellow"
+                variant="light"
+                icon={<AlertCircle size={16} />}
+              >
+                Documents can be uploaded once this booking has been dispatched.
+                It is currently{" "}
+                {detail?.booking?.schedulingStatus
+                  ?.toLowerCase()
+                  .replace(/_/g, " ") ?? "not dispatched"}
+                .
+              </Alert>
+            ) : null}
+
+            {viewerError ? (
+              <Alert
+                color="red"
+                variant="light"
+                icon={<AlertCircle size={16} />}
+              >
+                {viewerError}
+              </Alert>
+            ) : null}
+
+            <Stack gap="xs">
+              <Group gap="xs">
+                <Text size="sm" fw={600}>
+                  Uploaded
+                </Text>
+                <Badge size="sm" variant="light" circle={files.length < 10}>
+                  {files.length}
+                </Badge>
+              </Group>
+
+              {files.length === 0 ? (
+                <Card withBorder radius="md" py="lg">
+                  <Stack align="center" gap={4}>
+                    <FileIcon size={22} opacity={0.35} />
+                    <Text size="sm" c="dimmed">
+                      No documents uploaded yet.
+                    </Text>
+                  </Stack>
+                </Card>
+              ) : (
+                <ScrollArea.Autosize mah={260}>
+                  <Stack gap="xs">
+                    {files.map((file) => (
+                      <UploadedFileCard
+                        key={file.id}
+                        file={file}
+                        locked={locked}
+                        busy={busy}
+                        onView={() => openUploaded(file)}
+                        onRemove={() => removeMutation.mutate(file.id)}
+                      />
+                    ))}
+                  </Stack>
+                </ScrollArea.Autosize>
+              )}
+            </Stack>
+
+            {locked ? null : (
+              <>
+                <Stack gap="xs">
+                  <Group justify="space-between" align="center">
+                    <Text size="sm" fw={600}>
+                      Add documents
+                    </Text>
+                    <FileButton
+                      multiple
+                      onChange={(chosen) =>
+                        setPending((current) => [
+                          ...current,
+                          // Appended, not replaced: picking a second time must
+                          // add to the batch rather than discard the first pick
+                          // and the names already typed for it.
+                          ...chosen.map((file) => ({ file, title: "" })),
+                        ])
+                      }
+                    >
+                      {(props) => (
+                        <Button
+                          {...props}
+                          size="compact-sm"
+                          variant="light"
+                          leftSection={<Upload size={14} />}
+                          disabled={busy}
+                        >
+                          Choose files
+                        </Button>
+                      )}
+                    </FileButton>
+                  </Group>
+
+                  {pending.length > 0 ? (
+                    <>
+                      <ScrollArea.Autosize mah={180}>
+                        <Stack gap={6}>
+                          {pending.map((entry, index) => (
+                            <PendingFileCard
+                              key={`${entry.file.name}-${index}`}
+                              file={entry.file}
+                              title={entry.title}
+                              previewUrl={previews.get(entry.file) ?? ""}
+                              disabled={busy}
+                              onTitleChange={(title) =>
+                                setPending((current) =>
+                                  current.map((item, i) =>
+                                    i === index ? { ...item, title } : item,
+                                  ),
+                                )
+                              }
+                              onView={() =>
+                                view({
+                                  name: entry.title || entry.file.name,
+                                  url: previews.get(entry.file) ?? "",
+                                  mimeType: entry.file.type,
+                                })
+                              }
+                              onRemove={() =>
+                                setPending((current) =>
+                                  current.filter((_, i) => i !== index),
+                                )
+                              }
+                            />
+                          ))}
+                        </Stack>
+                      </ScrollArea.Autosize>
+                      <Group>
+                        <Button
+                          leftSection={<Upload size={15} />}
+                          loading={uploadMutation.isPending}
+                          onClick={() => uploadMutation.mutate()}
+                        >
+                          Upload {pending.length} file
+                          {pending.length === 1 ? "" : "s"}
+                        </Button>
+                        <Button
+                          variant="subtle"
+                          color="gray"
+                          disabled={busy}
+                          onClick={() => setPending([])}
+                        >
+                          Clear
+                        </Button>
+                      </Group>
+                    </>
+                  ) : null}
+
+                  {uploadMutation.isError ? (
+                    <Alert
+                      color="red"
+                      variant="light"
+                      icon={<AlertCircle size={16} />}
+                    >
+                      {(uploadMutation.error as Error).message}
+                    </Alert>
+                  ) : null}
+                </Stack>
+
+                <Textarea
+                  label="Note"
+                  placeholder="Anything worth recording about this clearance"
+                  value={note}
+                  onChange={(e) => setNote(e.currentTarget.value)}
+                  minRows={3}
+                  autosize
+                />
+
+                <Group justify="flex-end">
+                  <Button
+                    variant="default"
+                    loading={saveMutation.isPending}
+                    disabled={busy}
+                    onClick={() => saveMutation.mutate()}
+                  >
+                    {pending.length > 0
+                      ? `Save & upload ${pending.length}`
+                      : "Save"}
+                  </Button>
+                  <Button
+                    color="teal"
+                    leftSection={<Lock size={15} />}
+                    loading={finishMutation.isPending}
+                    disabled={busy}
+                    onClick={() => {
+                      // Finishing is one-way: it closes the assignment and locks
+                      // its documents, so confirm before doing it.
+                      if (
+                        window.confirm(
+                          pending.length > 0
+                            ? `Upload ${pending.length} staged file(s) and finish this assignment? Its documents will then be locked.`
+                            : "Finish this assignment? Its documents will be locked and can no longer be changed.",
+                        )
+                      ) {
+                        finishMutation.mutate();
+                      }
+                    }}
+                  >
+                    Finish
+                  </Button>
+                </Group>
+              </>
+            )}
+          </Stack>
+        )}
+      </Modal>
+      {viewer}
+    </>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/transit-agent/TransitAgentOverviewPage.tsx b/apps/edr-freight-web/portal/src/pages/transit-agent/TransitAgentOverviewPage.tsx
new file mode 100644
index 000000000..4db8c305c
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/transit-agent/TransitAgentOverviewPage.tsx
@@ -0,0 +1,654 @@
+import { Box, Button, Center, Group, Loader, Stack, Text } from "@mantine/core";
+import { useQuery } from "@tanstack/react-query";
+import {
+  AlertCircle,
+  ArrowRight,
+  FileCheck2,
+  FileX2,
+  Paperclip,
+  Play,
+  Target,
+  Timer,
+} from "lucide-react";
+import { useMemo } from "react";
+import { useNavigate } from "react-router-dom";
+
+import { Card } from "@/pages/MyPortalPage/components";
+import { cv } from "@/pages/MyPortalPage/constants";
+import {
+  transitAssignmentsService,
+  type TransitStatItem,
+  type TransitStats,
+} from "@/services/transit-assignments.service";
+
+/** Minutes as a compact "3h 10m" / "45m" — raw integers are unreadable in a grid. */
+function formatMinutes(minutes: number | null): string {
+  if (minutes === null) return "—";
+  const h = Math.floor(minutes / 60);
+  const m = minutes % 60;
+  return h ? `${h}h${m ? ` ${m}m` : ""}` : `${m}m`;
+}
+
+/** Split a duration so the number and its unit can be styled apart. */
+function splitDuration(minutes: number | null): [string, string] {
+  if (minutes === null) return ["—", ""];
+  if (minutes < 90) return [String(minutes), "min"];
+  return [(minutes / 60).toFixed(1), "hrs"];
+}
+
+const pctOf = (part: number, total: number) =>
+  total ? Math.round((part / total) * 100) : 0;
+
+type Tone = "green" | "amber" | "blue" | "slate" | "red";
+
+const TONES: Record<Tone, { soft: string; ink: string }> = {
+  green: { soft: cv("edr-soft"), ink: cv("edr-green.7") },
+  amber: { soft: cv("edr-amber-soft"), ink: cv("edr-amber-text") },
+  blue: { soft: cv("edr-blue-soft"), ink: cv("edr-blue") },
+  slate: { soft: cv("edr-slate-soft"), ink: cv("edr-slate") },
+  red: { soft: cv("edr-red-soft"), ink: cv("edr-red") },
+};
+
+/** Section heading shared by every panel, so the rhythm stays identical. */
+function PanelHead({
+  title,
+  hint,
+  right,
+}: {
+  title: string;
+  hint?: string;
+  right?: React.ReactNode;
+}) {
+  return (
+    <Group justify="space-between" align="start" wrap="nowrap" mb="md">
+      <Box>
+        <Text fz={15} fw={700} c="edr-text">
+          {title}
+        </Text>
+        {hint ? (
+          <Text fz={12} c="edr-muted" mt={2}>
+            {hint}
+          </Text>
+        ) : null}
+      </Box>
+      {right}
+    </Group>
+  );
+}
+
+/**
+ * One headline metric. Built on the portal's own KPI language — soft icon chip,
+ * tight numeral, muted label — rather than a generic bordered box per stat.
+ */
+function Kpi({
+  icon: Icon,
+  label,
+  value,
+  unit,
+  caption,
+  tone,
+  divider,
+}: {
+  icon: typeof Timer;
+  label: string;
+  value: string;
+  unit: string;
+  caption: string;
+  tone: Tone;
+  divider?: boolean;
+}) {
+  const t = TONES[tone];
+  return (
+    <Box
+      className={
+        divider
+          ? "flex flex-col border-t border-edr-divider pt-5 lg:border-l lg:border-t-0 lg:pl-6 lg:pt-0"
+          : "flex flex-col"
+      }
+    >
+      <Group gap={12} wrap="nowrap" align="start">
+        <Box
+          className="flex size-10 shrink-0 items-center justify-center rounded-xl"
+          style={{ background: t.soft }}
+        >
+          <Icon size={18} color={t.ink} strokeWidth={2} />
+        </Box>
+        <Box className="min-w-0">
+          <Group gap={5} align="baseline" wrap="nowrap">
+            <Text
+              fz={26}
+              fw={800}
+              lh={1.05}
+              c="edr-text"
+              className="tracking-tight"
+            >
+              {value}
+            </Text>
+            {unit ? (
+              <Text fz={12} fw={600} c="edr-muted">
+                {unit}
+              </Text>
+            ) : null}
+          </Group>
+          <Text fz={12} fw={600} c="edr-text" mt={6} truncate>
+            {label}
+          </Text>
+          <Text fz={11} c="edr-muted" truncate>
+            {caption}
+          </Text>
+        </Box>
+      </Group>
+    </Box>
+  );
+}
+
+/**
+ * One booking's arrival→clearance track: a pickup-lag segment followed by the
+ * clearance work, both on one shared scale so rows compare directly.
+ */
+function TimelineRow({
+  item,
+  scaleMax,
+}: {
+  item: TransitStatItem;
+  scaleMax: number;
+}) {
+  const pickup = item.pickupMinutes ?? 0;
+  const total = item.clearanceMinutes;
+  const work = total !== null ? Math.max(total - pickup, 0) : 0;
+  const pct = (v: number) => `${Math.min((v / scaleMax) * 100, 100)}%`;
+
+  const tone: Tone =
+    total === null
+      ? "slate"
+      : total <= 120
+        ? "green"
+        : total <= 360
+          ? "amber"
+          : "red";
+
+  return (
+    <Group gap="md" wrap="nowrap">
+      <Box className="w-[132px] shrink-0">
+        <Text fz={12} fw={700} c="edr-text" className="font-mono">
+          {item.reference?.replace("BK-2026-", "…") ?? "—"}
+        </Text>
+        <Text fz={10} c="edr-muted" truncate>
+          {item.customerName ?? "—"}
+        </Text>
+      </Box>
+
+      <Box className="flex h-8 flex-1 items-center overflow-hidden rounded-lg bg-edr-slate-soft2">
+        {pickup > 0 ? (
+          <Box
+            className="h-8 shrink-0"
+            style={{ width: pct(pickup), background: cv("edr-blue-dot") }}
+          />
+        ) : null}
+        {total !== null ? (
+          <Box
+            className="h-8 shrink-0"
+            style={{ width: pct(work), background: TONES[tone].ink }}
+          />
+        ) : (
+          <Text fz={10} c="edr-muted" pl="sm">
+            {item.status === "NOT_STARTED" ? "not started" : "in progress"}
+          </Text>
+        )}
+      </Box>
+
+      <Text
+        fz={12}
+        fw={700}
+        className="w-14 shrink-0 text-right font-mono"
+        style={{ color: total === null ? cv("edr-muted") : TONES[tone].ink }}
+      >
+        {formatMinutes(total)}
+      </Text>
+    </Group>
+  );
+}
+
+/** A single SLA band as a labelled proportional bar. */
+function SlaBar({
+  label,
+  count,
+  total,
+  tone,
+}: {
+  label: string;
+  count: number;
+  total: number;
+  tone: Tone;
+}) {
+  const pct = pctOf(count, total);
+  return (
+    <Box>
+      <Group justify="space-between" mb={6} wrap="nowrap">
+        <Group gap={8} wrap="nowrap">
+          <Box
+            className="size-2 shrink-0 rounded-full"
+            style={{ background: TONES[tone].ink }}
+          />
+          <Text fz={12} fw={600} c="edr-text">
+            {label}
+          </Text>
+        </Group>
+        <Text fz={12} c="edr-muted">
+          {count} · {pct}%
+        </Text>
+      </Group>
+      <Box className="h-1.5 overflow-hidden rounded-full bg-edr-slate-soft2">
+        <Box
+          className="h-full rounded-full"
+          style={{ width: `${pct}%`, background: TONES[tone].ink }}
+        />
+      </Box>
+    </Box>
+  );
+}
+
+/**
+ * The transit agent's dashboard: how quickly documents are filed after the
+ * train dispatches and arrives.
+ *
+ * Every figure comes from `GET /transit-assignments/my/stats`, which derives
+ * them from timestamps that already exist. The page renders what the API
+ * measured rather than recomputing, so the two cannot disagree.
+ */
+export default function TransitAgentOverviewPage() {
+  const navigate = useNavigate();
+  const query = useQuery({
+    queryKey: ["transit-stats"],
+    queryFn: transitAssignmentsService.stats,
+  });
+
+  const s: TransitStats | undefined = query.data;
+
+  const timeline = useMemo(
+    () =>
+      (s?.items ?? [])
+        .filter((i) => i.schedulingStatus === "DISPATCHED")
+        .slice(0, 6),
+    [s],
+  );
+
+  // One shared scale, capped at 6h: a single 47h outlier would otherwise
+  // compress every other row into an invisible sliver.
+  const scaleMax = useMemo(() => {
+    const measured = timeline
+      .map((i) => i.clearanceMinutes)
+      .filter((v): v is number => v !== null);
+    return Math.min(Math.max(...measured, 120) * 1.15, 360);
+  }, [timeline]);
+
+  if (query.isPending) {
+    return (
+      <Center h={420}>
+        <Loader size="sm" color="edr-green" />
+      </Center>
+    );
+  }
+
+  if (query.isError || !s) {
+    return (
+      <Box p={{ base: 16, sm: 24, lg: 32 }}>
+        <Card>
+          <Group gap="sm">
+            <AlertCircle size={18} color={cv("edr-red")} />
+            <Text fz={14} c="edr-text">
+              {(query.error as Error)?.message ??
+                "Could not load your overview."}
+            </Text>
+          </Group>
+        </Card>
+      </Box>
+    );
+  }
+
+  const { totals, performance, sla, coverage } = s;
+  const [medianValue, medianUnit] = splitDuration(
+    performance.medianClearanceMinutes,
+  );
+  const [pickupValue, pickupUnit] = splitDuration(
+    performance.medianPickupMinutes,
+  );
+  const uncovered = coverage.dispatched - coverage.withDocuments;
+  const coveragePct = pctOf(coverage.withDocuments, coverage.dispatched);
+
+  return (
+    <Box className="bg-edr-bg" p={{ base: 16, sm: 24, lg: 32 }}>
+      <Stack gap="lg">
+        <Group justify="space-between" align="end" wrap="wrap" gap="sm">
+          <Box>
+            <Text fz={26} fw={800} c="edr-text" className="tracking-tight">
+              Clearance performance
+            </Text>
+            <Text fz={13} c="edr-muted" mt={4}>
+              How fast documents are filed after the train dispatches and
+              arrives
+            </Text>
+          </Box>
+          {totals.open > 0 ? (
+            <Group
+              gap={8}
+              px={12}
+              py={7}
+              className="rounded-full"
+              style={{ background: cv("edr-soft") }}
+              wrap="nowrap"
+            >
+              <Box
+                className="size-1.5 rounded-full"
+                style={{ background: cv("edr-green.6") }}
+              />
+              <Text fz={12} fw={700} style={{ color: cv("edr-green.7") }}>
+                {totals.open} active now
+              </Text>
+            </Group>
+          ) : null}
+        </Group>
+
+        <Card>
+          <Box className="grid grid-cols-1 gap-5 sm:grid-cols-2 lg:grid-cols-4">
+            <Kpi
+              icon={Timer}
+              label="Median clearance"
+              value={medianValue}
+              unit={medianUnit}
+              caption={`across ${performance.measured} finished`}
+              tone="green"
+            />
+            <Kpi
+              icon={Play}
+              label="Pickup lag"
+              value={pickupValue}
+              unit={pickupUnit}
+              caption="arrival → work started"
+              tone="blue"
+              divider
+            />
+            <Kpi
+              icon={Paperclip}
+              label="Documents filed"
+              value={String(totals.documents)}
+              unit="files"
+              caption={`across ${totals.assignments} bookings`}
+              tone={uncovered > 0 ? "amber" : "green"}
+              divider
+            />
+            <Kpi
+              icon={Target}
+              label="On-time rate"
+              value={
+                performance.onTimeRate === null
+                  ? "—"
+                  : String(performance.onTimeRate)
+              }
+              unit={performance.onTimeRate === null ? "" : "%"}
+              caption="cleared within 6h"
+              tone="green"
+              divider
+            />
+          </Box>
+        </Card>
+
+        <Box className="grid grid-cols-1 gap-4 lg:grid-cols-3">
+          <Box className="lg:col-span-2">
+            <Card>
+              <PanelHead
+                title="Arrival → clearance"
+                hint="Time from the train arriving to documents filed"
+                right={
+                  <Group gap={14} wrap="nowrap">
+                    {(
+                      [
+                        [cv("edr-blue-dot"), "pickup"],
+                        [cv("edr-green.7"), "cleared"],
+                        [cv("edr-red"), "breach"],
+                      ] as const
+                    ).map(([color, label]) => (
+                      <Group gap={6} key={label} wrap="nowrap">
+                        <Box
+                          className="size-2 rounded-sm"
+                          style={{ background: color }}
+                        />
+                        <Text fz={11} c="edr-muted">
+                          {label}
+                        </Text>
+                      </Group>
+                    ))}
+                  </Group>
+                }
+              />
+              {timeline.length === 0 ? (
+                <Text fz={13} c="edr-muted" ta="center" py={40}>
+                  No dispatched bookings yet.
+                </Text>
+              ) : (
+                <Stack gap={14}>
+                  {timeline.map((item) => (
+                    <TimelineRow
+                      key={item.id}
+                      item={item}
+                      scaleMax={scaleMax}
+                    />
+                  ))}
+                </Stack>
+              )}
+            </Card>
+          </Box>
+
+          <Stack gap="md">
+            <Card>
+              <PanelHead
+                title="Clearance SLA"
+                right={
+                  <Text fz={11} c="edr-muted">
+                    {performance.measured} measured
+                  </Text>
+                }
+              />
+              <Stack gap={14}>
+                <SlaBar
+                  label="Under 2h"
+                  count={sla.under2h}
+                  total={performance.measured}
+                  tone="green"
+                />
+                <SlaBar
+                  label="2h – 6h"
+                  count={sla.under6h}
+                  total={performance.measured}
+                  tone="amber"
+                />
+                <SlaBar
+                  label="Over 6h"
+                  count={sla.over6h}
+                  total={performance.measured}
+                  tone="red"
+                />
+              </Stack>
+            </Card>
+
+            <Card>
+              <PanelHead
+                title="Document coverage"
+                hint="Dispatched bookings with evidence filed"
+              />
+              <Group align="baseline" gap={6} mb={10}>
+                <Text
+                  fz={30}
+                  fw={800}
+                  lh={1}
+                  c="edr-text"
+                  className="tracking-tight"
+                >
+                  {coveragePct}%
+                </Text>
+                <Text fz={12} c="edr-muted">
+                  {coverage.withDocuments} of {coverage.dispatched}
+                </Text>
+              </Group>
+              <Box className="mb-4 h-2 overflow-hidden rounded-full bg-edr-slate-soft2">
+                <Box
+                  className="h-full rounded-full"
+                  style={{
+                    width: `${coveragePct}%`,
+                    background:
+                      uncovered > 0 ? cv("edr-amber-text") : cv("edr-green.6"),
+                  }}
+                />
+              </Box>
+              {uncovered > 0 ? (
+                <Group
+                  gap={10}
+                  p={12}
+                  align="start"
+                  wrap="nowrap"
+                  className="mb-4 rounded-xl"
+                  style={{ background: cv("edr-amber-soft") }}
+                >
+                  <FileX2
+                    size={15}
+                    color={cv("edr-amber-text")}
+                    className="shrink-0"
+                  />
+                  <Text
+                    fz={11}
+                    lh={1.5}
+                    style={{ color: cv("edr-amber-text") }}
+                  >
+                    {uncovered} dispatched booking
+                    {uncovered === 1 ? " has" : "s have"} no documents filed.
+                  </Text>
+                </Group>
+              ) : (
+                <Group
+                  gap={10}
+                  p={12}
+                  align="start"
+                  wrap="nowrap"
+                  className="mb-4 rounded-xl"
+                  style={{ background: cv("edr-soft") }}
+                >
+                  <FileCheck2
+                    size={15}
+                    color={cv("edr-green.7")}
+                    className="shrink-0"
+                  />
+                  <Text fz={11} lh={1.5} style={{ color: cv("edr-green.7") }}>
+                    Every dispatched booking has evidence filed.
+                  </Text>
+                </Group>
+              )}
+              <Button
+                fullWidth
+                color="edr-green"
+                rightSection={<ArrowRight size={15} />}
+                onClick={() => navigate("/transit-agent/bookings")}
+              >
+                {uncovered > 0 ? "File missing documents" : "Open bookings"}
+              </Button>
+            </Card>
+          </Stack>
+        </Box>
+
+        <Card padding={0}>
+          <Box px={24} pt={20} pb={14}>
+            <PanelHead
+              title="Recent assignments"
+              right={
+                <Text fz={11} c="edr-muted">
+                  {totals.assignments} total
+                </Text>
+              }
+            />
+          </Box>
+          <Box>
+            {s.items.slice(0, 6).map((item) => (
+              <Group
+                key={item.id}
+                justify="space-between"
+                px={24}
+                py={14}
+                wrap="nowrap"
+                className="border-t border-edr-divider"
+              >
+                <Group gap="md" wrap="nowrap" className="min-w-0 flex-1">
+                  <Text
+                    fz={12}
+                    fw={600}
+                    c="edr-text"
+                    className="w-[132px] font-mono"
+                  >
+                    {item.reference ?? "—"}
+                  </Text>
+                  <Box
+                    px={9}
+                    py={3}
+                    className="shrink-0 rounded-full"
+                    style={{
+                      background:
+                        item.status === "FINISHED"
+                          ? cv("edr-soft")
+                          : item.status === "IN_PROGRESS"
+                            ? cv("edr-blue-soft")
+                            : cv("edr-slate-soft"),
+                    }}
+                  >
+                    <Text
+                      fz={10}
+                      fw={700}
+                      style={{
+                        color:
+                          item.status === "FINISHED"
+                            ? cv("edr-green.7")
+                            : item.status === "IN_PROGRESS"
+                              ? cv("edr-blue")
+                              : cv("edr-slate"),
+                      }}
+                    >
+                      {item.status === "FINISHED"
+                        ? "Finished"
+                        : item.status === "IN_PROGRESS"
+                          ? "In progress"
+                          : "Not started"}
+                    </Text>
+                  </Box>
+                  <Text fz={12} c="edr-muted" truncate>
+                    {item.customerName ?? "—"}
+                  </Text>
+                </Group>
+                <Group gap={22} wrap="nowrap" className="shrink-0">
+                  <Text fz={12} c="edr-muted" className="font-mono">
+                    {formatMinutes(item.clearanceMinutes)}
+                  </Text>
+                  <Group gap={6} wrap="nowrap" className="w-10">
+                    {item.documentCount > 0 ? (
+                      <FileCheck2 size={13} color={cv("edr-green.6")} />
+                    ) : (
+                      <FileX2 size={13} color={cv("edr-step-idle")} />
+                    )}
+                    <Text
+                      fz={12}
+                      className="font-mono"
+                      style={{
+                        color:
+                          item.documentCount > 0
+                            ? cv("edr-green.7")
+                            : cv("edr-muted"),
+                      }}
+                    >
+                      {item.documentCount}
+                    </Text>
+                  </Group>
+                </Group>
+              </Group>
+            ))}
+          </Box>
+        </Card>
+      </Stack>
+    </Box>
+  );
+}
diff --git a/apps/edr-freight-web/portal/src/pages/transit-agent/index.ts b/apps/edr-freight-web/portal/src/pages/transit-agent/index.ts
new file mode 100644
index 000000000..663743845
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/pages/transit-agent/index.ts
@@ -0,0 +1,2 @@
+export { default as TransitAgentOverviewPage } from "./TransitAgentOverviewPage";
+export { default as TransitAgentBookingsPage } from "./TransitAgentBookingsPage";
diff --git a/apps/edr-freight-web/portal/src/services/companies.service.ts b/apps/edr-freight-web/portal/src/services/companies.service.ts
index 466d82470..bd3f7d5e9 100644
--- a/apps/edr-freight-web/portal/src/services/companies.service.ts
+++ b/apps/edr-freight-web/portal/src/services/companies.service.ts
@@ -103,7 +103,7 @@ export interface CompanyProfileResponse {
  * "shipping line" would skip onboarding for customers whenever the request
  * failed. Absent (older responses) means `customer`.
  */
-export type AccountKind = "customer" | "shipping_line";
+export type AccountKind = "customer" | "shipping_line" | "transit_agent";
 
 export interface CompanyInfoResponse {
   accountKind?: AccountKind;
@@ -138,13 +138,38 @@ export interface ShippingLineInfoResponse {
   review: null;
 }
 
-/** `GET /companies/getInfo` serves both portal audiences. */
-export type AccountInfoResponse = CompanyInfoResponse | ShippingLineInfoResponse;
+/**
+ * A signed-in transit agent. Like a shipping line it has no company, no
+ * external profile and no onboarding — the agent record itself is the account.
+ */
+export interface TransitAgentInfoResponse {
+  accountKind: "transit_agent";
+  id: string;
+  name: string;
+  email: string | null;
+  phoneNumber: string | null;
+  isActive: boolean;
+  validFrom: string;
+  validTo: string;
+  company: null;
+  profile: null;
+  review: null;
+}
+
+/** `GET /companies/getInfo` serves every portal audience. */
+export type AccountInfoResponse =
+  | CompanyInfoResponse
+  | ShippingLineInfoResponse
+  | TransitAgentInfoResponse;
 
 export const isShippingLineAccount = (
   info: AccountInfoResponse | null | undefined,
 ): info is ShippingLineInfoResponse => info?.accountKind === "shipping_line";
 
+export const isTransitAgentAccount = (
+  info: AccountInfoResponse | null | undefined,
+): info is TransitAgentInfoResponse => info?.accountKind === "transit_agent";
+
 /** A staged profile-edit review request (portal view). */
 export interface ChangeRequestResponse {
   id: string;
diff --git a/apps/edr-freight-web/portal/src/services/transit-assignments.service.ts b/apps/edr-freight-web/portal/src/services/transit-assignments.service.ts
new file mode 100644
index 000000000..31b633add
--- /dev/null
+++ b/apps/edr-freight-web/portal/src/services/transit-assignments.service.ts
@@ -0,0 +1,172 @@
+import { client } from "@/utils/api";
+
+const BASE = "/api/transit-assignments/my";
+
+/** One document attached to an assignment. */
+export interface TransitAssignmentFile {
+  id: string;
+  name: string;
+  title: string | null;
+  url: string;
+  size: number;
+  mimeType: string;
+  uploadedAt: string;
+  updatedAt: string;
+  uploadedByName: string | null;
+}
+
+export type TransitAssignmentStatus =
+  | "NOT_STARTED"
+  | "IN_PROGRESS"
+  | "FINISHED";
+
+/**
+ * One booking assigned to the signed-in transit agent.
+ *
+ * `canUploadDocuments` is computed server-side from BOTH gates (the booking is
+ * dispatched, and the assignment is not finished). The UI reads that flag
+ * rather than re-deriving the rule, so the button state cannot drift from what
+ * the API will actually accept.
+ */
+export interface TransitAssignment {
+  id: string;
+  bookingId: string;
+  transitAgentId: string;
+  status: TransitAssignmentStatus;
+  startedAt: string | null;
+  finishedAt: string | null;
+  assignedAt: string;
+  note: string | null;
+  timeAfterTrainArrives: number | null;
+  canUploadDocuments: boolean;
+  /** Whose cargo this is — flattened server-side off the booking's company. */
+  customerName: string | null;
+  files?: TransitAssignmentFile[];
+  booking?: {
+    id: string;
+    reference?: string | null;
+    status?: string | null;
+    schedulingStatus?: string | null;
+    tradeDirection?: string | null;
+    arrivedAt?: string | null;
+  } | null;
+}
+
+export interface TransitAssignmentListParams {
+  search?: string;
+  status?: TransitAssignmentStatus;
+  schedulingStatus?: string;
+  page?: number;
+  pageSize?: number;
+}
+
+export interface TransitAssignmentListResult {
+  items: TransitAssignment[];
+  meta: { total: number; page: number; pageSize: number; totalPages: number };
+}
+
+/** One row behind the overview's timeline and activity list. */
+export interface TransitStatItem {
+  id: string;
+  reference: string | null;
+  customerName: string | null;
+  status: TransitAssignmentStatus;
+  schedulingStatus: string | null;
+  transitMinutes: number | null;
+  pickupMinutes: number | null;
+  clearanceMinutes: number | null;
+  documentCount: number;
+}
+
+/**
+ * Overview figures, all derived server-side from existing timestamps. Every
+ * duration is minutes, and null means "not measurable yet" rather than zero —
+ * an unfinished assignment has no clearance time.
+ */
+export interface TransitStats {
+  totals: {
+    assignments: number;
+    open: number;
+    finished: number;
+    readyForDocuments: number;
+    documents: number;
+  };
+  performance: {
+    medianClearanceMinutes: number | null;
+    medianPickupMinutes: number | null;
+    fastestClearanceMinutes: number | null;
+    slowestClearanceMinutes: number | null;
+    onTimeRate: number | null;
+    measured: number;
+  };
+  sla: { under2h: number; under6h: number; over6h: number };
+  coverage: { dispatched: number; withDocuments: number };
+  items: TransitStatItem[];
+}
+
+export const transitAssignmentsService = {
+  /** Dashboard figures for the signed-in agent. */
+  stats: async (): Promise<TransitStats> => {
+    const { data } = await client.get(`${BASE}/stats`);
+    return data.data ?? data;
+  },
+
+  /**
+   * Bookings assigned to me. Filtering and paging are server-side: an agent's
+   * roster grows without bound, so the page must not depend on holding every
+   * row in the browser.
+   */
+  list: async (
+    params: TransitAssignmentListParams = {},
+  ): Promise<TransitAssignmentListResult> => {
+    const { data } = await client.get(BASE, { params });
+    return data.data ?? data;
+  },
+
+  /** One assignment, with its documents. */
+  getById: async (id: string): Promise<TransitAssignment> => {
+    const { data } = await client.get(`${BASE}/${id}`);
+    return data.data ?? data;
+  },
+
+  /**
+   * Upload staged documents, each with its own display name.
+   *
+   * `titles` is positional: one entry appended per file, in the same order, so
+   * the API can pair index N with file N. Sending them as a keyed object is not
+   * possible here — two files may legitimately share a filename.
+   */
+  uploadFiles: async (
+    id: string,
+    files: { file: File; title?: string }[],
+  ): Promise<TransitAssignmentFile[]> => {
+    const formData = new FormData();
+    // One field name for every file — the API keys each record by
+    // `file.fieldname`, and these are free-form documents with no fixed slots.
+    for (const entry of files) {
+      formData.append("document", entry.file);
+      formData.append("titles", entry.title?.trim() || "");
+    }
+
+    const { data } = await client.post(`${BASE}/${id}/files`, formData, {
+      headers: { "Content-Type": "multipart/form-data" },
+    });
+    return data.data ?? data;
+  },
+
+  removeFile: async (id: string, fileId: string): Promise<void> => {
+    await client.delete(`${BASE}/${id}/files/${fileId}`);
+  },
+
+  /**
+   * Save progress, or finish. Finishing locks the assignment's documents, so
+   * the caller should confirm before passing `finish: true`.
+   */
+  submit: async (
+    id: string,
+    input: { finish: boolean; note?: string },
+  ): Promise<TransitAssignment> => {
+    const { data } = await client.post(`${BASE}/${id}/submit`, input);
+    return data.data ?? data;
+  },
+};
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index a89b5ee80..6e9da8bbc 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -481,6 +481,9 @@ importers:
       react-pdf-html:
         specifier: ^2.1.5
         version: 2.1.5(@react-pdf/renderer@4.5.1(react@19.2.6))(react@19.2.6)
+      react-phone-number-input:
+        specifier: ^3.4.17
+        version: 3.4.17(react-dom@19.2.6(react@19.2.6))(react@19.2.6)
       react-quill-new:
         specifier: ^3.8.3
         version: 3.8.3(quill-delta@5.1.0)(react-dom@19.2.6(react@19.2.6))(react@19.2.6)