fix: start visits unassigned

Remove the greedy route seeding pass from Bergamo demo data so every generated technician route starts with an empty visits list. The demo payload now represents the real planning starting point: work exists as service visits, but no technician owns it until the solver assigns it.

Add an assigned_visits hard constraint that requires every service visit to appear exactly once in the route lists. This keeps unassigned demo data from becoming an acceptable final solution and also treats duplicate or invalid visit indexes as hard issues.

Update the managed SolverForge constraint metadata and generated UI model to include the new hard constraint, while keeping route_metrics as an internal helper module only. The map sidebar now renders an Unassigned visits table so the empty initial route state is visible in the stock SolverForge UI workspace.

solverforge.app.toml

@@ -50,6 +50,11 @@ elements = "service_visits"
 allows_unassigned = false
 enabled = true
 
+[[constraints]]
+name = "assigned_visits"
+module = "assigned_visits"
+enabled = true
+
 [[constraints]]
 name = "balance_workload"
 module = "balance_workload"

src/constraints/assigned_visits.rs

@@ -0,0 +1,168 @@
+use crate::domain::FieldServicePlan;
+use solverforge::prelude::*;
+use solverforge::IncrementalConstraint;
+
+/// HARD: every service visit must appear exactly once in a technician route.
+pub fn constraint() -> impl IncrementalConstraint<FieldServicePlan, HardSoftScore> {
+    AssignedVisitsConstraint
+}
+
+struct AssignedVisitsConstraint;
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+struct AssignmentIssues {
+    unassigned: i64,
+    duplicate_assignments: i64,
+    invalid_assignments: i64,
+}
+
+impl AssignmentIssues {
+    fn total(self) -> i64 {
+        self.unassigned + self.duplicate_assignments + self.invalid_assignments
+    }
+}
+
+impl IncrementalConstraint<FieldServicePlan, HardSoftScore> for AssignedVisitsConstraint {
+    fn evaluate(&self, solution: &FieldServicePlan) -> HardSoftScore {
+        HardSoftScore::of(-assignment_issues(solution).total(), 0)
+    }
+
+    fn match_count(&self, solution: &FieldServicePlan) -> usize {
+        assignment_issues(solution).total() as usize
+    }
+
+    fn initialize(&mut self, solution: &FieldServicePlan) -> HardSoftScore {
+        self.evaluate(solution)
+    }
+
+    fn on_insert(
+        &mut self,
+        solution: &FieldServicePlan,
+        _entity_index: usize,
+        _descriptor_index: usize,
+    ) -> HardSoftScore {
+        self.evaluate(solution)
+    }
+
+    fn on_retract(
+        &mut self,
+        solution: &FieldServicePlan,
+        _entity_index: usize,
+        _descriptor_index: usize,
+    ) -> HardSoftScore {
+        -self.evaluate(solution)
+    }
+
+    fn reset(&mut self) {}
+
+    fn name(&self) -> &str {
+        "Assigned Visits"
+    }
+
+    fn is_hard(&self) -> bool {
+        true
+    }
+
+    fn weight(&self) -> HardSoftScore {
+        HardSoftScore::of(1, 0)
+    }
+}
+
+fn assignment_issues(plan: &FieldServicePlan) -> AssignmentIssues {
+    let mut counts = vec![0usize; plan.service_visits.len()];
+    let mut issues = AssignmentIssues::default();
+
+    for route in &plan.technician_routes {
+        for &visit_idx in &route.visits {
+            if let Some(count) = counts.get_mut(visit_idx) {
+                *count += 1;
+            } else {
+                issues.invalid_assignments += 1;
+            }
+        }
+    }
+
+    for count in counts {
+        match count {
+            0 => issues.unassigned += 1,
+            1 => {}
+            extra => issues.duplicate_assignments += (extra - 1) as i64,
+        }
+    }
+
+    issues
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::domain::{
+        FieldServicePlan, ServiceVisit, ServiceVisitInit, TechnicianRoute, TechnicianRouteInit,
+    };
+    use solverforge::IncrementalConstraint;
+
+    #[test]
+    fn empty_routes_are_penalized_for_unassigned_visits() {
+        let score = constraint().evaluate(&sample_plan(vec![vec![]]));
+
+        assert_eq!(score, HardSoftScore::of(-2, 0));
+    }
+
+    #[test]
+    fn every_visit_once_is_feasible() {
+        let score = constraint().evaluate(&sample_plan(vec![vec![0, 1]]));
+
+        assert_eq!(score, HardSoftScore::ZERO);
+    }
+
+    #[test]
+    fn duplicate_or_invalid_visit_indexes_are_hard_issues() {
+        let score = constraint().evaluate(&sample_plan(vec![vec![0, 0, 99]]));
+
+        assert_eq!(score, HardSoftScore::of(-3, 0));
+    }
+
+    fn sample_plan(route_visits: Vec<Vec<usize>>) -> FieldServicePlan {
+        let service_visits = (0..2)
+            .map(|idx| {
+                ServiceVisit::new(ServiceVisitInit {
+                    id: format!("visit-{idx}"),
+                    name: format!("Visit {idx}"),
+                    customer: format!("Customer {idx}"),
+                    location_idx: idx,
+                    duration_minutes: 30,
+                    earliest_minute: 480,
+                    latest_minute: 1020,
+                    required_skill_mask: 0,
+                    required_parts_mask: 0,
+                    priority: 1,
+                    territory: "center".to_string(),
+                })
+            })
+            .collect();
+        let technician_routes = route_visits
+            .into_iter()
+            .enumerate()
+            .map(|(idx, visits)| {
+                let mut route = TechnicianRoute::new(TechnicianRouteInit {
+                    id: format!("route-{idx}"),
+                    technician_id: format!("tech-{idx}"),
+                    technician_name: format!("Tech {idx}"),
+                    color: "#2563eb".to_string(),
+                    start_location_idx: 0,
+                    end_location_idx: 0,
+                    shift_start_minute: 480,
+                    shift_end_minute: 1020,
+                    max_route_minutes: 480,
+                    skill_mask: 0,
+                    inventory_mask: 0,
+                    territory: "center".to_string(),
+                });
+                route.visits = visits;
+                route
+            })
+            .collect();
+
+        FieldServicePlan::new(Vec::new(), service_visits, Vec::new(), technician_routes)
+    }
+}

src/constraints/mod.rs

@@ -11,6 +11,7 @@ pub use self::assemble::create_constraints;
 pub mod route_metrics;
 
 // @solverforge:begin constraint-modules
+mod assigned_visits;
 mod balance_workload;
 mod minimize_travel;
 mod priority_slack;
@@ -28,6 +29,7 @@ mod assemble {
     pub fn create_constraints() -> impl ConstraintSet<FieldServicePlan, HardSoftScore> {
         // @solverforge:begin constraint-calls
         (
+            assigned_visits::constraint(),
             balance_workload::constraint(),
             minimize_travel::constraint(),
             priority_slack::constraint(),

src/data/data_seed.rs

@@ -7,7 +7,6 @@ use solverforge_maps::{
     encode_polyline, BoundingBox, Coord, NetworkConfig, RoadNetwork, RoutingError, UNREACHABLE,
 };
 
-use crate::constraints::route_metrics::{route_stats, RouteStats};
 use crate::domain::{
     FieldServicePlan, Location, ServiceVisit, ServiceVisitInit, TechnicianRoute,
     TechnicianRouteInit, TravelLeg, TravelLegInit,
@@ -116,13 +115,7 @@ pub async fn generate(demo: DemoData) -> Result<FieldServicePlan, DemoDataError>
     let matrix = network.compute_matrix(&coords, None).await;
     let travel_legs = build_travel_legs(&network, &matrix, &coords);
     let service_visits = build_service_visits(demo);
-    let mut technician_routes = build_technician_routes(demo);
-    seed_initial_routes(
-        &locations,
-        &service_visits,
-        &travel_legs,
-        &mut technician_routes,
-    );
+    let technician_routes = build_technician_routes(demo);
 
     Ok(FieldServicePlan::new(
         locations,
@@ -202,91 +195,6 @@ fn build_technician_routes(demo: DemoData) -> Vec<TechnicianRoute> {
         .collect()
 }
 
-fn seed_initial_routes(
-    locations: &[Location],
-    service_visits: &[ServiceVisit],
-    travel_legs: &[TravelLeg],
-    technician_routes: &mut [TechnicianRoute],
-) {
-    let mut order = (0..service_visits.len()).collect::<Vec<_>>();
-    order.sort_by_key(|&idx| {
-        let visit = &service_visits[idx];
-        (visit.latest_minute, -visit.priority)
-    });
-
-    for visit_idx in order {
-        if let Some((route_idx, insert_pos)) = best_insertion(
-            locations,
-            service_visits,
-            travel_legs,
-            technician_routes,
-            visit_idx,
-        ) {
-            technician_routes[route_idx]
-                .visits
-                .insert(insert_pos, visit_idx);
-        }
-    }
-}
-
-fn best_insertion(
-    locations: &[Location],
-    service_visits: &[ServiceVisit],
-    travel_legs: &[TravelLeg],
-    technician_routes: &[TechnicianRoute],
-    visit_idx: usize,
-) -> Option<(usize, usize)> {
-    let plan = FieldServicePlan::new(
-        locations.to_vec(),
-        service_visits.to_vec(),
-        travel_legs.to_vec(),
-        technician_routes.to_vec(),
-    );
-    let mut best: Option<(InsertionCost, usize, usize)> = None;
-
-    for (route_idx, route) in technician_routes.iter().enumerate() {
-        for insert_pos in 0..=route.visits.len() {
-            let mut candidate = route.clone();
-            candidate.visits.insert(insert_pos, visit_idx);
-            let cost = insertion_cost(&plan, &candidate);
-            if best
-                .as_ref()
-                .map(|(best_cost, _, _)| cost < *best_cost)
-                .unwrap_or(true)
-            {
-                best = Some((cost, route_idx, insert_pos));
-            }
-        }
-    }
-
-    best.map(|(_, route_idx, insert_pos)| (route_idx, insert_pos))
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-struct InsertionCost {
-    hard: i64,
-    soft: i64,
-}
-
-fn insertion_cost(plan: &FieldServicePlan, route: &TechnicianRoute) -> InsertionCost {
-    let stats = route_stats(plan, route);
-    InsertionCost {
-        hard: hard_issue_count(&stats),
-        soft: stats.travel_minutes() + stats.route_minutes
-            - (stats.territory_matches * 10)
-            - stats.priority_slack,
-    }
-}
-
-fn hard_issue_count(stats: &RouteStats) -> i64 {
-    stats.invalid_visits
-        + stats.unreachable_legs
-        + stats.missing_skill_visits
-        + stats.missing_part_visits
-        + stats.late_minutes
-        + stats.overtime_minutes
-}
-
 fn build_travel_legs(
     network: &RoadNetwork,
     matrix: &solverforge_maps::TravelTimeMatrix,
@@ -703,3 +611,18 @@ const TECHNICIANS: &[TechnicianSeed] = &[
         territory: "east",
     },
 ];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn generated_technician_routes_start_without_assigned_visits() {
+        for demo in DemoData::available_demo_data() {
+            let routes = build_technician_routes(*demo);
+
+            assert!(!routes.is_empty());
+            assert!(routes.iter().all(|route| route.visits.is_empty()));
+        }
+    }
+}

static/app.js

@@ -387,6 +387,7 @@
 
   function renderRouteCards(plan) {
     routeCards.innerHTML = '';
+    renderUnassignedCard(plan);
     (plan.technician_routes || []).forEach(function (route) {
       var stats = routeStats(plan, route);
       var card = SF.el('div', {
@@ -418,6 +419,35 @@
     });
   }
 
+  function renderUnassignedCard(plan) {
+    var assigned = assignedVisitSet(plan.technician_routes || []);
+    var rows = (plan.service_visits || []).reduce(function (items, visit, idx) {
+      if (assigned[idx]) return items;
+      items.push([
+        visit.customer || visit.name || visit.id,
+        timeLabel(visit.earliest_minute) + '-' + timeLabel(visit.latest_minute),
+        formatDuration(visit.duration_minutes || 0),
+      ]);
+      return items;
+    }, []);
+    if (!rows.length) return;
+
+    var card = SF.el('div', {
+      className: 'sf-section',
+      style: {
+        borderLeft: '4px solid #64748b',
+        padding: '12px',
+        borderRadius: '8px',
+      },
+    });
+    card.appendChild(SF.el('h3', { style: { margin: '0 0 8px' } }, 'Unassigned visits'));
+    card.appendChild(SF.createTable({
+      columns: ['Visit', 'Window', 'Duration'],
+      rows: rows,
+    }));
+    routeCards.appendChild(card);
+  }
+
   function renderTimeline(plan) {
     var timelineConfig = buildTimelineConfig(plan);
     timelineContainer.innerHTML = '';

static/generated/ui-model.json

@@ -1,5 +1,6 @@
 {
   "constraints": [
+    "assigned_visits",
     "balance_workload",
     "minimize_travel",
     "priority_slack",

static/sf-config.json

@@ -2,6 +2,7 @@
   "title": "Bergamo Field Service Routing",
   "subtitle": "Technician routes, road travel, time windows, skills, and parts",
   "constraints": [
+    "assigned_visits",
     "reachable_legs",
     "required_skills",
     "required_parts",