Add AICL example: 41_warehouse_mgmt.aicl

data/aicl/examples/41_warehouse_mgmt.aicl

@@ -0,0 +1,402 @@
+# AICL Example: Warehouse Management System
+# Comprehensive warehouse management platform covering inventory control, pick-pack-ship operations, slotting optimization, labor management, and cross-dock coordination for high-throughput distribution centers
+
+Goal: Deliver a warehouse management system that maximizes storage utilization through intelligent slotting, optimizes pick-path efficiency, ensures inventory accuracy through cycle counting and reconciliation, coordinates inbound and outbound logistics, and provides real-time visibility into warehouse operations for workforce and capacity planning
+
+Constraint: Inventory movements must maintain lot traceability from receipt through shipment for regulatory compliance
+Constraint: Pick assignments must respect weight limits, hazmat segregation, and product compatibility constraints
+Constraint: Slotting optimization must not reassign active picks or reserved inventory without coordination window
+Constraint: Shipping manifest must match load plan with zero discrepancy before carrier release
+Constraint: Cycle count variances above materiality threshold must trigger root cause investigation before adjustment
+
+Risk: Inventory accuracy degradation below 98 percent causing fulfillment errors and customer complaints
+Recovery: Trigger emergency full physical count for affected zones; implement blind recount verification; analyze variance patterns by SKU and location; adjust counting frequency for high-variance items; enforce receiving inspection protocols
+
+Risk: Pick-path congestion during peak hours causing throughput bottleneck and missed shipping windows
+Recovery: Implement dynamic pick-wave staggering; activate overflow pick zones; deploy temporary labor augmentation; adjust cartonization logic to reduce partial picks; resequence waves by priority and proximity
+
+Risk: Slotting misassignment placing incompatible products in proximity causing contamination or damage
+Recovery: Immediately relocate affected products to quarantine zone; inspect for contamination or damage; validate product compatibility matrix; correct slotting algorithm constraints; audit recent slotting assignments for similar violations
+
+Risk: Shipping manifest discrepancy discovered after carrier departure causing delivery and billing errors
+Recovery: Notify carrier of discrepancy with corrected manifest; alert customer service for affected orders; generate supplemental manifest; adjust inventory records; implement pre-ship verification checkpoint enhancement
+
+Risk: Receiving dock bottleneck from unplanned inbound volume exceeding staging capacity
+Recovery: Activate overflow receiving area; implement appointment-based receiving schedule; prioritize receipts for backorder fulfillment; deploy cross-dock bypass for pre-allocated items; coordinate with transportation on delivery rescheduling
+
+Risk: Labor allocation imbalance between zones causing idle resources in some areas and overtime in others
+Recovery: Implement real-time labor balancing dashboard; cross-train associates for multi-zone flexibility; activate dynamic task interleaving; adjust shift start times based on workload forecast; deploy supervisor reallocation authority
+
+Layer: InventoryControl
+    SubLayer: StockTracking
+    SubLayer: LotManagement
+    SubLayer: CycleCounting
+    SubLayer: InventoryAdjustment
+
+Layer: InboundOperations
+    SubLayer: DockScheduling
+    SubLayer: Receiving
+    SubLayer: Putaway
+    SubLayer: CrossDock
+
+Layer: OutboundOperations
+    SubLayer: OrderWavePlanning
+    SubLayer: Picking
+    SubLayer: Packing
+    SubLayer: Shipping
+
+Layer: SlottingOptimization
+    SubLayer: VelocityAnalysis
+    SubLayer: CompatibilityEngine
+    SubLayer: SlotAssignment
+    SubLayer: ReplenishmentPlanning
+
+Layer: LaborManagement
+    SubLayer: WorkforceScheduling
+    SubLayer: TaskAssignment
+    SubLayer: PerformanceTracking
+    SubLayer: TrainingCompliance
+
+Validation: All inventory receipts must reference a valid purchase order or transfer order before putaway
+Validation: Pick quantities must exactly match order line quantities with zero tolerance for overpick
+Validation: Packing operations must validate order completeness and generate accurate weight and dimension data
+Validation: Shipping manifests must reconcile all packed cartons against load plan before carrier release
+Validation: Slot assignments must pass product compatibility and physical constraint validation before activation
+Validation: Cycle count adjustments must include root cause codes and supervisor approval for variances exceeding threshold
+
+Entity InventoryItem
+    sku: string
+    productName: string
+    category: string
+    lotNumber: string
+    expirationDate: datetime
+    quantityOnHand: float
+    quantityReserved: float
+    quantityAvailable: float
+    locationId: string
+    abcVelocity: string
+    productGroup: string
+    hazmatClass: string
+    temperatureRange: dict
+
+Entity PickTask
+    taskId: string
+    waveId: string
+    orderId: string
+    sku: string
+    lotNumber: string
+    sourceLocation: string
+    targetLocation: string
+    pickQuantity: float
+    pickedQuantity: float
+    assignedTo: string
+    priority: integer
+    status: string
+    createdAt: datetime
+    completedAt: datetime
+
+Entity SlotAssignment
+    slotId: string
+    warehouseCode: string
+    zone: string
+    aisle: string
+    rack: string
+    level: string
+    slotType: string
+    assignedSku: string
+    velocityClass: string
+    capacityUnits: float
+    utilizedUnits: float
+    compatibilityGroup: string
+    replenishmentSource: string
+    lastReassigned: datetime
+
+Entity ShipmentManifest
+    manifestId: string
+    carrierId: string
+    trailerId: string
+    doorAssignment: string
+    orderCount: integer
+    cartonCount: integer
+    totalWeight: float
+    totalCube: float
+    status: string
+    shipments: list
+    sealNumber: string
+    departureTime: datetime
+    complianceChecks: dict
+
+Entity ReceiptRecord
+    receiptId: string
+    purchaseOrderRef: string
+    supplierId: string
+    dockDoor: string
+    receivedBy: string
+    receiptDate: datetime
+    expectedQuantity: float
+    receivedQuantity: float
+    damagedQuantity: float
+    qualityHoldQuantity: float
+    lotNumbers: list
+    putawayComplete: boolean
+    inspectionRequired: boolean
+
+Entity LaborAllocation
+    allocationId: string
+    employeeId: string
+    zone: string
+    shift: string
+    taskType: string
+    assignedTasks: integer
+    completedTasks: integer
+    unitsProcessed: float
+    efficiencyRate: float
+    startTime: datetime
+    endTime: datetime
+    overtimeHours: float
+    crossTrainedZones: list
+
+Behavior ReceiveInboundShipment
+    Input: purchaseOrderRef: string, dockDoor: string, receivedQuantities: list, lotData: list
+    Output: receiptRecord: ReceiptRecord
+    Action: Validate purchase order reference; assign dock door and staging lane; record received quantities per line; capture lot numbers and expiration dates; flag damaged items for inspection; quarantine quality hold items; update inventory positions; emit receipt event; trigger putaway task generation
+
+Behavior GeneratePickWave
+    Input: orderPool: list, priorityRules: dict, capacityConstraints: dict
+    Output: wavePlan: dict
+    Action: Select orders for wave based on priority and ship-by dates; group by zone for pick efficiency; generate pick tasks with optimal path sequence; assign cartonization rules; check inventory availability; allocate inventory to tasks; emit wave released event; update order fulfillment status
+
+Behavior ExecutePutaway
+    Input: receiptId: string, sku: string, quantity: float, lotNumber: string
+    Output: putawayConfirmation: dict
+    Action: Determine optimal putaway location via slotting rules; verify location compatibility and capacity; generate putaway task; guide associate to location; confirm placement with scan verification; update inventory position; emit putaway complete event; replenish forward pick locations if needed
+
+Behavior OptimizeSlotting
+    Input: warehouseCode: string, strategy: string, constraints: dict
+    Output: slottingPlan: dict
+    Action: Analyze product velocity and pick frequency data; evaluate product compatibility constraints; calculate optimal slot assignments by velocity class; respect physical constraints of rack and zone; minimize replenishment travel distance; generate reassignment plan with coordination windows; simulate throughput improvement; emit slotting plan event; schedule phased reassignment
+
+Behavior PackAndVerify
+    Input: orderId: string, pickedItems: list, cartonizationRules: dict
+    Output: packResult: dict
+    Action: Validate all order lines are present; apply cartonization logic for optimal box selection; scan verify each item into carton; capture weight and dimensions; generate packing slip and shipping label; validate against order completeness; emit pack complete event; update shipment manifest; trigger shipping workflow
+
+Behavior ProcessCycleCount
+    Input: zone: string, skuList: list, countMethod: string
+    Output: countResult: dict
+    Action: Generate count tasks for selected items; assign counters with blind count protocol; record physical counts; compare against system quantities; flag variances above threshold; require recount for flagged items; initiate root cause investigation; apply approved adjustments; update inventory positions; emit count complete event
+
+Condition:
+    When inventoryItem.quantityAvailable falls below minimumDisplayQuantity AND item is in forward pick location
+    Then trigger replenishment task from reserve storage; calculate replenishment quantity based on velocity; prioritize replenishment task; notify zone supervisor; update pick availability flag
+
+Condition:
+    When pickTask.pickedQuantity does not equal pickTask.pickQuantity AND variance exceeds shortShipTolerance
+    Then place pick task on exception hold; notify order management of potential short ship; trigger inventory discrepancy investigation; adjust available quantity; generate exception pick if substitute available
+
+Condition:
+    When slotAssignment.utilizedUnits exceeds 95 percent of capacityUnits AND velocity class is A
+    Then flag for slot expansion or relocation to higher-capacity position; adjust replenishment parameters; recommend slotting reoptimization; prevent new SKU assignments to slot; notify slotting coordinator
+
+Condition:
+    When shipmentManifest complianceChecks contain any failed items
+    Then hold manifest from carrier release; notify shipping supervisor; generate resolution tasks; require re-verification after correction; log compliance failure for audit; escalate persistent failures
+
+Condition:
+    When laborAllocation.efficiencyRate falls below 75 percent for two consecutive shifts
+    Then trigger performance review notification; analyze task assignment appropriateness; evaluate training needs; adjust zone assignment; recommend cross-training; alert shift supervisor
+
+Event:
+    On ReceiptCompleted
+    Action: Update inventory positions; generate putaway tasks; trigger quality inspection if required; update purchase order receipt status; emit inbound dashboard refresh; calculate dock-to-stock time; update supplier delivery metrics
+
+Event:
+    On PickWaveReleased
+    Action: Assign pick tasks to available associates; update pick path displays; activate zone workload indicators; notify packing stations of expected volume; refresh outbound dashboard; start pick timing metrics
+
+Event:
+    On SlottingReassignmentComplete
+    Action: Update inventory location records; refresh pick path algorithms; update replenishment source mappings; validate forward pick availability; emit slotting update event; recalculate zone capacity metrics
+
+Event:
+    On ShipmentDispatched
+    Action: Finalize inventory deductions; transmit manifest to carrier; update order tracking; generate bill of lading; close shipment record; emit outbound dashboard refresh; update carrier performance tracking
+
+Event:
+    On CycleCountVarianceDetected
+    Action: Initiate root cause investigation; flag SKU for increased count frequency; adjust inventory valuation if material; notify inventory control manager; update accuracy metrics; log variance for trend analysis
+
+Parallel:
+    - Inbound receiving and putaway task processing
+    - Outbound pick wave generation and task assignment
+    - Real-time slotting optimization calculation
+    - Cycle count scheduling and variance analysis
+    - Labor efficiency monitoring and reallocation
+
+Optimize: Warehouse throughput and inventory accuracy
+    Priority: Inventory accuracy and lot traceability over processing speed
+    Priority: Order fulfillment completeness over throughput volume
+    Priority: Product safety and compliance over storage density
+    Priority: Associate safety and ergonomics over pick speed
+
+Learn: Pick path efficiency optimization
+    Goal: Reduce average pick travel time by 20 percent through path learning
+    Adapt: Pick task sequencing and zone grouping algorithms
+    Based: Historical pick completion times, path traversal data, and congestion patterns
+
+Learn: Slotting velocity prediction
+    Goal: Predict SKU velocity class changes 4 weeks in advance with 70 percent accuracy
+    Adapt: Slot assignment and replenishment parameters
+    Based: Demand trend analysis, seasonal patterns, and promotional calendar impact
+
+Learn: Receiving dock scheduling optimization
+    Goal: Reduce dock-to-stock time by 25 percent through appointment optimization
+    Adapt: Dock appointment scheduling and labor pre-allocation
+    Based: Historical receiving volume patterns, supplier delivery window adherence, and putaway velocity
+
+Learn: Labor demand forecasting
+    Goal: Predict zone labor requirements within 10 percent of actual 2 weeks in advance
+    Adapt: Workforce scheduling and cross-training priorities
+    Based: Order volume forecasts, seasonal workload patterns, and historical productivity rates
+
+Security:
+    Encrypt: All inventory valuation and cost data at rest and in transit
+    Encrypt: Supplier proprietary information including lot and batch data
+    Encrypt: Employee performance and labor allocation data with access restriction
+    Protect: Inventory adjustment transactions with dual-authorization and audit trail
+    Protect: Shipping manifest data with carrier-specific access controls
+    Protect: Slotting optimization algorithms and parameters as proprietary business logic
+    Protect: Cycle count results from premature visibility to maintain blind count integrity
+
+Native: python
+{
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Tuple
+import math
+
+class SlottingOptimizer:
+    """Warehouse slotting optimization with velocity and compatibility constraints."""
+
+    def __init__(self, warehouse_config: Dict, compatibility_matrix: Dict):
+        self.config = warehouse_config
+        self.compatibility = compatibility_matrix
+
+    def optimize(self, sku_velocity: Dict, current_assignments: Dict,
+                 strategy: str = "velocity") -> Dict:
+        ranked_skus = sorted(sku_velocity.items(), key=lambda x: x[1]["picks_per_day"], reverse=True)
+        forward_slots = self._get_forward_slots()
+        reserve_slots = self._get_reserve_slots()
+
+        plan = {"assignments": [], "relocations": [], "estimated_impact": {}}
+
+        # Assign top velocity SKUs to most accessible forward positions
+        for i, (sku, velocity) in enumerate(ranked_skus):
+            if i < len(forward_slots):
+                target_slot = forward_slots[i]
+                current = current_assignments.get(sku)
+                if current and current != target_slot["slot_id"]:
+                    plan["relocations"].append({
+                        "sku": sku,
+                        "from_slot": current,
+                        "to_slot": target_slot["slot_id"],
+                        "reason": "velocity_optimization"
+                    })
+                plan["assignments"].append({
+                    "sku": sku,
+                    "slot_id": target_slot["slot_id"],
+                    "zone": target_slot["zone"],
+                    "velocity_class": "A" if i < len(forward_slots) * 0.2 else "B"
+                })
+            else:
+                target_slot = reserve_slots[i - len(forward_slots)] if i - len(forward_slots) < len(reserve_slots) else reserve_slots[-1]
+                plan["assignments"].append({
+                    "sku": sku,
+                    "slot_id": target_slot["slot_id"],
+                    "zone": target_slot["zone"],
+                    "velocity_class": "C"
+                })
+
+        plan["estimated_impact"] = self._simulate_impact(plan, sku_velocity)
+        return plan
+
+    def _get_forward_slots(self) -> List[Dict]:
+        slots = []
+        for zone in self.config["zones"]:
+            if zone["type"] == "forward_pick":
+                for aisle in range(1, zone["aisle_count"] + 1):
+                    for level in range(1, zone["level_count"] + 1):
+                        # Lower levels and center aisles are more accessible
+                        accessibility = (zone["aisle_count"] - abs(aisle - zone["aisle_count"]/2)) + (zone["level_count"] - level)
+                        slots.append({
+                            "slot_id": f"{zone['code']}-A{aisle:02d}-L{level:02d}",
+                            "zone": zone["code"],
+                            "accessibility_score": accessibility
+                        })
+        return sorted(slots, key=lambda s: s["accessibility_score"], reverse=True)
+
+    def _get_reserve_slots(self) -> List[Dict]:
+        slots = []
+        for zone in self.config["zones"]:
+            if zone["type"] == "reserve_storage":
+                for rack in range(1, zone["rack_count"] + 1):
+                    slots.append({
+                        "slot_id": f"{zone['code']}-R{rack:03d}",
+                        "zone": zone["code"],
+                        "accessibility_score": 0
+                    })
+        return slots
+
+    def _simulate_impact(self, plan: Dict, velocity: Dict) -> Dict:
+        current_travel = sum(v["avg_pick_travel_min"] for v in velocity.values())
+        # Estimate 20% improvement for velocity-based slotting
+        estimated_travel = current_travel * 0.80
+        return {
+            "current_avg_pick_travel_min": round(current_travel, 1),
+            "estimated_avg_pick_travel_min": round(estimated_travel, 1),
+            "improvement_percent": 20.0,
+            "relocation_count": len(plan["relocations"])
+        }
+
+
+class PickWaveGenerator:
+    """Generates optimized pick waves from order pools."""
+
+    def __init__(self, zone_config: Dict):
+        self.zones = zone_config
+
+    def generate_wave(self, orders: List[Dict], max_orders: int = 50) -> Dict:
+        prioritized = sorted(orders, key=lambda o: (
+            -o.get("priority", 0),
+            o.get("ship_by", datetime.max).isoformat()
+        ))[:max_orders]
+
+        zone_groups = {}
+        for order in prioritized:
+            for line in order["lines"]:
+                zone = self._get_zone_for_sku(line["sku"])
+                if zone not in zone_groups:
+                    zone_groups[zone] = []
+                zone_groups[zone].append({
+                    "order_id": order["order_id"],
+                    "sku": line["sku"],
+                    "qty": line["qty"],
+                    "location": line.get("location")
+                })
+
+        wave_id = f"WV-{datetime.utcnow().strftime('%Y%m%d%H%M%S')}"
+        return {
+            "wave_id": wave_id,
+            "order_count": len(prioritized),
+            "zone_groups": zone_groups,
+            "estimated_units": sum(
+                sum(l["qty"] for l in lines) for lines in zone_groups.values()
+            ),
+            "released_at": datetime.utcnow().isoformat()
+        }
+
+    def _get_zone_for_sku(self, sku: str) -> str:
+        for zone, config in self.zones.items():
+            if sku.startswith(tuple(config.get("sku_prefixes", []))):
+                return zone
+        return "default"
+}