Fix:

Added assertCapacity() checks before saving (matches single receive)
Added applyCapacityDelta() after save to increment counters
Now validates warehouse → yard → zone capacity hierarchy
Single receive already had both checks; bulk receive was gap.

apps/edr-freight-api/src/modules/maintenance/entities/maintenance-schedule.entity.ts

@@ -62,4 +62,8 @@ export class MaintenanceSchedule extends BaseEntity {
 
   @Column({ name: 'next_due_date', type: 'timestamptz', nullable: true })
   nextDueDate?: Date;
+
+  /** Stamped once the km/date-due alert has fired, so the daily check doesn't repeat it. */
+  @Column({ name: 'due_notified_at', type: 'timestamptz', nullable: true })
+  dueNotifiedAt?: Date;
 }

apps/edr-freight-api/src/modules/maintenance/maintenance.controller.ts

@@ -44,6 +44,13 @@ export class MaintenanceController {
     return this.maintenanceService.updateMaintenanceSchedule(id, dto);
   }
 
+  @Get('due-board')
+  @BookingStaff([FREIGHT_PERMS.maintenance.view, FREIGHT_PERMS.fleetDashboard.view])
+  @ApiOperation({ summary: 'Fleet-wide next-due maintenance board (by date and km)' })
+  async getDueBoard() {
+    return this.maintenanceService.getDueBoard();
+  }
+
   @Get('upcoming/:vehicleId')
   @BookingStaff(FREIGHT_PERMS.maintenance.view)
   @ApiOperation({ summary: 'Get upcoming maintenance' })

apps/edr-freight-api/src/modules/maintenance/maintenance.module.ts

@@ -12,10 +12,12 @@ import { WorkOrderRepository } from './work-order.repository';
 import { PartRepository } from './part.repository';
 import { WarrantyRepository } from './warranty.repository';
 import { MaintenanceController } from './maintenance.controller';
+import { NotificationInboxModule } from '../notification-inbox/notification-inbox.module';
 
 @Module({
   imports: [
     TypeOrmModule.forFeature([MaintenanceSchedule, MaintenanceCost, WorkOrder, Part, Warranty]),
+    NotificationInboxModule,
   ],
   providers: [
     MaintenanceService,

apps/edr-freight-api/src/modules/maintenance/maintenance.repository.ts

@@ -47,4 +47,105 @@ export class MaintenanceRepository extends BaseRepository<MaintenanceSchedule> {
       .getRawOne();
     return result?.total || 0;
   }
+
+  /**
+   * Fleet-wide "next due" board: one row per vehicle with a SCHEDULED
+   * maintenance item, driven by time AND km — whichever is soonest. Current km
+   * is the vehicle's latest fuel-up odometer reading (how mileage is actually
+   * captured today), falling back to vehicle.actual_distance_km when the
+   * vehicle has no fuel purchase on file yet.
+   */
+  async getDueBoard(): Promise<
+    Array<{
+      scheduleId: string;
+      vehicleId: string;
+      plateNumber: string;
+      maintenanceType: string;
+      description: string;
+      scheduledDate: Date;
+      nextDueDate: Date | null;
+      nextDueKm: number | null;
+      currentKm: number | null;
+      kmRemaining: number | null;
+      daysRemaining: number | null;
+      overdue: boolean;
+    }>
+  > {
+    return this.scheduleRepository.manager.query(`
+      SELECT DISTINCT ON (s.vehicle_id)
+        s.id AS "scheduleId",
+        s.vehicle_id AS "vehicleId",
+        v.plate_number AS "plateNumber",
+        s.maintenance_type AS "maintenanceType",
+        s.description,
+        s.scheduled_date AS "scheduledDate",
+        s.next_due_date AS "nextDueDate",
+        s.next_due_km AS "nextDueKm",
+        COALESCE(fp.max_odometer, v.actual_distance_km) AS "currentKm",
+        CASE WHEN s.next_due_km IS NOT NULL
+          THEN s.next_due_km - COALESCE(fp.max_odometer, v.actual_distance_km, 0)
+          ELSE NULL END AS "kmRemaining",
+        CASE WHEN s.next_due_date IS NOT NULL
+          THEN EXTRACT(DAY FROM s.next_due_date - now())
+          ELSE NULL END AS "daysRemaining",
+        (
+          (s.next_due_date IS NOT NULL AND s.next_due_date <= now())
+          OR (s.next_due_km IS NOT NULL
+              AND COALESCE(fp.max_odometer, v.actual_distance_km, 0) >= s.next_due_km)
+        ) AS overdue
+      FROM freight.maintenance_schedules s
+      JOIN freight.vehicles v ON v.id = s.vehicle_id AND v.deleted_at IS NULL
+      LEFT JOIN LATERAL (
+        SELECT MAX(odometer_reading) AS max_odometer
+        FROM freight.fuel_purchases fp2
+        WHERE fp2.vehicle_id = s.vehicle_id
+      ) fp ON true
+      WHERE s.status = 'SCHEDULED' AND s.deleted_at IS NULL
+      ORDER BY s.vehicle_id, s.scheduled_date ASC
+    `);
+  }
+
+  /**
+   * SCHEDULED items that have crossed their km or date due-point and have not
+   * yet been notified. Backs the daily km/date maintenance alert.
+   */
+  async getUnnotifiedDue(): Promise<
+    Array<{
+      id: string;
+      vehicleId: string;
+      plateNumber: string;
+      maintenanceType: string;
+      description: string;
+      nextDueKm: number | null;
+      nextDueDate: Date | null;
+      currentKm: number | null;
+    }>
+  > {
+    return this.scheduleRepository.manager.query(`
+      SELECT
+        s.id,
+        s.vehicle_id AS "vehicleId",
+        v.plate_number AS "plateNumber",
+        s.maintenance_type AS "maintenanceType",
+        s.description,
+        s.next_due_km AS "nextDueKm",
+        s.next_due_date AS "nextDueDate",
+        COALESCE(fp.max_odometer, v.actual_distance_km) AS "currentKm"
+      FROM freight.maintenance_schedules s
+      JOIN freight.vehicles v ON v.id = s.vehicle_id AND v.deleted_at IS NULL
+      LEFT JOIN LATERAL (
+        SELECT MAX(odometer_reading) AS max_odometer
+        FROM freight.fuel_purchases fp2
+        WHERE fp2.vehicle_id = s.vehicle_id
+      ) fp ON true
+      WHERE s.status = 'SCHEDULED'
+        AND s.deleted_at IS NULL
+        AND s.due_notified_at IS NULL
+        AND (
+          (s.next_due_date IS NOT NULL AND s.next_due_date <= now())
+          OR (s.next_due_km IS NOT NULL
+              AND COALESCE(fp.max_odometer, v.actual_distance_km, 0) >= s.next_due_km)
+        )
+    `);
+  }
 }

apps/edr-freight-api/src/modules/maintenance/maintenance.service.ts

@@ -1,14 +1,19 @@
-import { Injectable } from '@nestjs/common';
+import { Injectable, Logger } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { NotificationAudience, NotificationType } from '@edr/types';
 import { DataSource, Repository } from 'typeorm';
 import { MaintenanceRepository } from './maintenance.repository';
 import { MaintenanceSchedule, MaintenanceStatus } from './entities/maintenance-schedule.entity';
 import { MaintenanceCost } from './entities/maintenance-cost.entity';
 import { Vehicle, VehicleAvailability, VehicleStatus } from '../vehicles/entities/vehicle.entity';
 import { CreateMaintenanceScheduleDto, CreateMaintenanceCostDto, UpdateMaintenanceScheduleDto } from './dto/create-maintenance.dto';
+import { NotificationInboxService } from '../notification-inbox/notification-inbox.service';
 
 @Injectable()
 export class MaintenanceService {
+  private readonly logger = new Logger(MaintenanceService.name);
+
   constructor(
     private readonly maintenanceRepository: MaintenanceRepository,
     @InjectRepository(MaintenanceSchedule)
@@ -18,8 +23,44 @@ export class MaintenanceService {
     // Vehicle isn't registered in this module's TypeOrmModule.forFeature, so we
     // reach it through the global DataSource rather than @InjectRepository.
     private readonly dataSource: DataSource,
+    private readonly inbox: NotificationInboxService,
   ) {}
 
+  /** Fleet-wide next-due board — see MaintenanceRepository.getDueBoard. */
+  async getDueBoard() {
+    return this.maintenanceRepository.getDueBoard();
+  }
+
+  /**
+   * Daily check: a vehicle's driven km (latest fuel-up odometer reading, since
+   * that's the only place mileage is actually recorded) or its due date has
+   * reached a SCHEDULED item's threshold → alert backoffice once.
+   */
+  @Cron(CronExpression.EVERY_DAY_AT_7AM, { name: 'maintenance-due-alert' })
+  async sendDueAlerts(): Promise<void> {
+    try {
+      const due = await this.maintenanceRepository.getUnnotifiedDue();
+      for (const item of due) {
+        const reason =
+          item.nextDueKm != null && (item.currentKm ?? 0) >= item.nextDueKm
+            ? `driven ${item.currentKm} km (due at ${item.nextDueKm} km)`
+            : `due ${new Date(item.nextDueDate as Date).toLocaleDateString()}`;
+        await this.inbox.notify({
+          recipients: { allBackoffice: true },
+          audience: NotificationAudience.BACKOFFICE,
+          type: NotificationType.GENERIC,
+          title: `Maintenance due — ${item.plateNumber}`,
+          body: `${item.plateNumber} (${item.maintenanceType}) is due for maintenance — ${reason}. ${item.description}`,
+          link: `/dashboard/maintenance?vehicleId=${item.vehicleId}`,
+          data: { vehicleId: item.vehicleId, scheduleId: item.id, action: 'MAINTENANCE_DUE' },
+        });
+        await this.scheduleRepository.update(item.id, { dueNotifiedAt: new Date() });
+      }
+    } catch (err) {
+      this.logger.error(`sendDueAlerts failed: ${(err as Error).message}`, (err as Error).stack);
+    }
+  }
+
   /**
    * Reflect a maintenance schedule's lifecycle on the target vehicle. A vehicle
    * under maintenance is taken out of service (MAINTENANCE + BUSY); once the