feat(dispatch): VRP route optimizer (OR-Tools) — "Optimiser" mode

Real vehicle-routing optimization behind the Suggérer UI, reusing our
existing OR-Tools solver service (no new stack). Fixes the greedy's
structural limits (sector-splitting, no global optimization).

- roster-solver: new route_solver.py (OR-Tools Routing / VRPTW).
  Minimizes real travel; skills = hard filter (VehicleVar ∈ allowed∪{-1};
  SetAllowedVehiclesForIndex has a broken Span typemap in ortools 9.15);
  on-site service time within each tech's shift window; optional per-job
  time windows; unfittable jobs left unassigned (drop penalty) instead of
  infeasible; specialist bias via skill order (per-vehicle arc cost).
  New POST /route endpoint. Dockerfile now COPYs route_solver.py.
  Unit-tested: skills respected, sectors consolidated, edge cases safe.
- hub: POST /roster/optimize-routes → proxies to solver /route.
- ops SPA: "⚡ Optimiser" strategy. Greedy buckets jobs into days +
  placeholders, then the solver re-optimizes each day (assignment +
  routes) among shifted techs; result maps into the same review dialog
  (occupation bars, route map, swap/merge reused). Graceful fallback to
  greedy if the solver is unreachable (never drops jobs). shiftWindowMin
  derives each vehicle's shift from templates.

Phase 2 (later): OSRM/Mapbox road-time matrix for exact travel times.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

apps/ops/src/api/roster.js

@@ -98,6 +98,8 @@ export const jobCandidates = (job, exclude) => jget('/roster/job-candidates?job=
 export const redistributePlan = (plan) => jpost('/roster/skill-impact/redistribute', { plan })
 // Jobs non assignés (+ groupe/dépendances) pour le panneau glisser-déposer
 export const unassignedJobs = () => jget('/roster/unassigned-jobs')
+// Optimisation de tournées (VRPTW + compétences + temps sur place) via le solveur OR-Tools. payload = { jobs[], vehicles[], ... }
+export const optimizeRoutes = (payload) => jpost('/roster/optimize-routes', payload)
 // Write-back legacy : aperçu (0 écriture) puis application (réassigne ticket.assign_to au tech dans osTicket)
 export const pushLegacyPreview = () => jget('/dispatch/legacy-sync/push-assignments')
 export const pushLegacyApply = (notify = true) => jpost('/dispatch/legacy-sync/push-assignments' + (notify ? '' : '?notify=0'), {})

apps/ops/src/pages/PlanificationPage.vue

@@ -975,8 +975,8 @@
           <template v-if="suggestDlg.mode === 'config'">
             <div class="row items-center q-mb-sm" style="gap:6px;flex-wrap:wrap">
               <span class="text-caption text-grey-7 q-mr-xs">Stratégie :</span>
-              <q-btn-toggle v-model="suggestDlg.strategy" dense no-caps unelevated toggle-color="primary" color="grey-3" text-color="grey-8" :options="[{ label: 'Intelligent', value: 'smart' }, { label: 'Meilleurs d\'abord', value: 'best' }, { label: 'Équilibré', value: 'balance' }, { label: 'Juste ce qu\'il faut', value: 'enough' }]" />
+              <q-btn-toggle v-model="suggestDlg.strategy" dense no-caps unelevated toggle-color="primary" color="grey-3" text-color="grey-8" :options="[{ label: '⚡ Optimiser', value: 'optimize' }, { label: 'Intelligent', value: 'smart' }, { label: 'Meilleurs d\'abord', value: 'best' }, { label: 'Équilibré', value: 'balance' }, { label: 'Juste ce qu\'il faut', value: 'enough' }]" />
-              <span class="text-caption text-grey-6">{{ ({ smart: 'proximité + compétence + charge', best: 'concentre le travail sur les meilleurs (cascade)', balance: 'répartit également entre tous (round-robin)', enough: 'qualifié mais le moins sur-qualifié → réserve les experts (distance + temps pris en compte)' })[suggestDlg.strategy] }}</span>
+              <span class="text-caption text-grey-6">{{ ({ optimize: 'solveur VRP (OR-Tools) : routes réelles minimisées + compétences + temps sur place — regroupe les secteurs, spécialistes d\'abord', smart: 'proximité + compétence + charge', best: 'concentre le travail sur les meilleurs (cascade)', balance: 'répartit également entre tous (round-robin)', enough: 'qualifié mais le moins sur-qualifié → réserve les experts (distance + temps pris en compte)' })[suggestDlg.strategy] }}</span>
             </div>
             <div class="text-caption q-mb-sm" style="color:#475569;background:#eef2ff;border-radius:6px;padding:4px 8px"><q-icon name="date_range" size="14px" class="q-mr-xs" color="primary" />Répartit sur : <b>{{ suggestWindowLabel }}</b><span class="text-grey-6"> — défaut aujourd'hui + demain ; filtre par date (chips de la liste) pour cibler d'autres jours. Les jobs datés au-delà sont laissés pour plus tard.</span></div>
             <div class="row items-center q-mb-xs" style="gap:4px">
@@ -4057,12 +4057,51 @@ function techQuality (t) {
   return (5 - avgLvl) * 2 + (eff - 1) * 5 + ((Number(t.cost_h) || 0) / 100) // plus BAS = meilleur
 }
 const suggestTechsRanked = computed(() => [...(visibleTechs.value || [])].sort((a, b) => techQuality(a) - techQuality(b)))
-function runSuggestion () {
+async function runSuggestion () {
   if (!suggestSelCount.value) { $q.notify({ type: 'warning', message: 'Choisis au moins un technicien disponible.', timeout: 2500 }); return }
-  suggestDlg.building = true; buildSuggestion(); suggestDlg.building = false
+  suggestDlg.building = true
+  try {
+    if (suggestDlg.strategy === 'optimize') await optimizeSuggestion() // solveur VRP OR-Tools (routes + compétences + temps sur place)
+    else buildSuggestion()                                             // heuristique gloutonne (rapide, local)
+  } catch (e) { err(e); buildSuggestion() } finally { suggestDlg.building = false }
   suggestDlg.view = 'list'; suggestMapDay.value = suggestWindow.value[0] || '' // carte des tournées : 1er jour de la fenêtre par défaut
   suggestDlg.mode = 'review'
 }
+// Fenêtre de quart (min depuis minuit) d'un tech un jour donné, depuis ses cellules + le modèle. null si aucun quart régulier.
+function shiftWindowMin (techId, iso) {
+  let s = Infinity, e = -Infinity
+  for (const a of cellsOf(techId, iso)) { const t = tplByName.value[a.shift]; if (!t || t.on_call) continue; const ss = hToNum(t.start_time), ee = hToNum(t.end_time); if (ss != null) s = Math.min(s, ss); if (ee != null) e = Math.max(e, ee <= ss ? 24 : ee) }
+  if (!isFinite(s) || !isFinite(e) || e <= s) return null
+  return { start: Math.round(s * 60), end: Math.round(e * 60) }
+}
+// « Optimiser » = le greedy décide le JOUR (buckets + placeholders), puis le solveur VRP OR-Tools ré-optimise CHAQUE jour
+// (assignation + routes) parmi les techs de quart → regroupe les secteurs, respecte compétences + temps sur place.
+async function optimizeSuggestion () {
+  buildSuggestion() // pose les jours + skill/dur/coords/reqLevel sur chaque entrée + les placeholders week-end/sans-quart
+  const plan = suggestDlg.plan
+  const out = plan.filter(e => e.placeholder) // placeholders conservés
+  const byDay = {}
+  for (const e of plan) if (!e.placeholder) (byDay[e.iso] = byDay[e.iso] || []).push(e)
+  const selTechs = (visibleTechs.value || []).filter(t => suggestDlg.techSel[t.id])
+  for (const iso of Object.keys(byDay)) {
+    const entries = byDay[iso]
+    const byName = Object.fromEntries(entries.map(e => [e.jobName, e]))
+    const jobs = entries.map(e => ({ id: e.jobName, lat: e.lat, lon: e.lon, service_min: Math.max(5, Math.round((e.dur || 1) * 60)), skill: e.skill || '' }))
+    const vehicles = []
+    for (const t of selTechs) { const w = shiftWindowMin(t.id, iso); if (!w) continue; const h = techHomes.value[t.id]; vehicles.push({ id: t.id, name: t.name, skills: t.skills || [], home_lat: (h && isFinite(+h.lat)) ? +h.lat : null, home_lon: (h && isFinite(+h.lon)) ? +h.lon : null, shift_start_min: w.start, shift_end_min: w.end }) }
+    if (!vehicles.length) { out.push(...entries); continue } // aucun tech de quart ce jour → garder l'assignation greedy
+    let res
+    try { res = await roster.optimizeRoutes({ jobs, vehicles, max_seconds: 8, rank_weight: 6 }) } catch (e) { out.push(...entries); continue }
+    if (!res || res.status !== 'OK') { out.push(...entries); continue } // solveur absent/erreur/infaisable → on GARDE l'assignation greedy (ne jamais perdre de jobs)
+    const placed = new Set()
+    for (const rt of (res.routes || [])) {
+      const t = selTechs.find(x => x.id === rt.vehicle) || { id: rt.vehicle, name: rt.vehicle_name }
+      for (const st of (rt.stops || [])) { const e0 = byName[st.job_id]; if (!e0) continue; placed.add(st.job_id); out.push({ ...e0, techId: t.id, techName: t.name, noShift: false, capable: true }) }
+    }
+    for (const jid of (res.unassigned || [])) { const e0 = byName[jid]; if (!e0 || placed.has(jid)) continue; out.push({ ...e0, techId: `__hold__|${iso}|opt`, techName: `⏳ ${FR_DOW[dowOf(iso)] || ''} ${iso.slice(8)} — non casé (à assigner)`, placeholder: true, noShift: false }) }
+  }
+  suggestDlg.plan = out
+}
 // D v2 — ordonne une tournée par PLUS-PROCHE-VOISIN depuis le domicile du tech + distance totale (haversine, sans appel réseau).
 function nnOrder (entries, home) {
   const pts = entries.filter(e => e.lat != null && e.lon != null)

services/roster-solver/Dockerfile

@@ -4,7 +4,7 @@ WORKDIR /app
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY solver.py app.py ./
+COPY solver.py app.py route_solver.py ./
 
 EXPOSE 8090
 # 1 worker : CP-SAT est déjà multi-thread (num_search_workers=8)

services/roster-solver/app.py

@@ -14,8 +14,9 @@ from typing import Any
 import os
 
 from solver import solve_roster
+from route_solver import solve_route
 
-app = FastAPI(title="Roster AI Solver", version="0.1.0")
+app = FastAPI(title="Roster AI Solver", version="0.2.0")
 
 API_TOKEN = os.environ.get("ROSTER_SOLVER_TOKEN", "")
 
@@ -29,6 +30,17 @@ class SolveRequest(BaseModel):
     max_seconds: float | None = None
 
 
+class RouteRequest(BaseModel):
+    jobs: list
+    vehicles: list
+    matrix: list | None = None
+    speed_kmh: float | None = None
+    default_service_min: int | None = None
+    rank_weight: float | None = None
+    drop_penalty: int | None = None
+    max_seconds: float | None = None
+
+
 @app.get("/health")
 def health():
     return {"ok": True, "service": "roster-solver"}
@@ -41,3 +53,12 @@ def solve(req: SolveRequest):
         return result
     except Exception as e:  # noqa: BLE001 — renvoyer l'erreur proprement au hub
         return JSONResponse(status_code=400, content={"status": "ERROR", "message": str(e)})
+
+
+@app.post("/route")
+def route(req: RouteRequest):
+    """Optimisation de TOURNÉES (VRPTW + compétences + temps sur place). Voir route_solver.solve_route."""
+    try:
+        return solve_route(req.model_dump())
+    except Exception as e:  # noqa: BLE001
+        return JSONResponse(status_code=400, content={"status": "ERROR", "message": str(e)})

services/roster-solver/route_solver.py

@@ -0,0 +1,200 @@
+"""
+Dispatch VRP — solveur de TOURNÉES (OR-Tools Routing / CP).
+
+Problème : VRPTW + compétences + temps sur place (« field service »).
+  • nœuds = jobs ; véhicules = techniciens (chacun part/revient à SON domicile)
+  • compétence requise du job = filtre DUR (véhicules autorisés)
+  • temps sur place (service) + trajet comptent dans la dimension TEMPS, bornée
+    par le quart de chaque tech (fenêtre) ; fenêtre horaire par job optionnelle
+  • objectif : MINIMISER le trajet total (+ léger biais spécialiste via l'ordre
+    des compétences du tech) ; un job qui ne rentre pas est laissé NON planifié
+    (pénalité de « drop ») plutôt que de rendre le modèle infaisable.
+
+C'est ce que le greedy ne peut pas faire : optimisation GLOBALE → regroupe les
+jobs d'un même secteur sur le même tech (plus de fractionnement).
+
+Entrée (dict) :
+  jobs: [{id, lat, lon, service_min, skill, tw_start_min?, tw_end_min?, priority_boost?}]
+  vehicles: [{id, name, skills:[...] (ORDRE = priorité), home_lat?, home_lon?,
+              shift_start_min, shift_end_min}]
+  matrix?: [[minutes]] (N_jobs+N_veh carré, jobs d'abord puis domiciles) — sinon haversine
+  speed_kmh?, default_service_min?, rank_weight?, drop_penalty?, max_seconds?
+Sortie : {status, routes:[{vehicle, vehicle_name, stops:[{job_id,arrival_min,service_min}],
+          travel_min}], unassigned:[job_id], total_travel_min, objective, solve_ms}
+"""
+from __future__ import annotations
+import math
+from ortools.constraint_solver import pywrapcp, routing_enums_pb2
+
+
+def _haversine_km(a, b) -> float:
+    (lat1, lon1), (lat2, lon2) = a, b
+    R = 6371.0
+    p1, p2 = math.radians(lat1), math.radians(lat2)
+    dphi = math.radians(lat2 - lat1)
+    dlmb = math.radians(lon2 - lon1)
+    h = math.sin(dphi / 2) ** 2 + math.cos(p1) * math.cos(p2) * math.sin(dlmb / 2) ** 2
+    return 2 * R * math.asin(min(1.0, math.sqrt(h)))
+
+
+def solve_route(req: dict) -> dict:
+    all_jobs = req.get("jobs", []) or []
+    vehicles = req.get("vehicles", []) or []
+    if not all_jobs or not vehicles:
+        return {"status": "EMPTY", "routes": [], "unassigned": [j["id"] for j in all_jobs],
+                "total_travel_min": 0, "objective": None, "solve_ms": 0}
+
+    speed = float(req.get("speed_kmh") or 45.0)
+    default_service = int(req.get("default_service_min") or 60)
+    rank_w = float(req.get("rank_weight") or 5.0)   # « minutes virtuelles » par cran d'ordre de compétence (spécialiste=0)
+    base_pen = int(req.get("drop_penalty") or 100000)
+    max_seconds = float(req.get("max_seconds") or 10)
+
+    def skill_ok(veh, sk):
+        return (not sk) or (sk in (veh.get("skills") or []))
+
+    # Pré-filtre : un job sans AUCUN tech compétent est non planifiable → hors modèle (évite les "allowed" vides).
+    jobs, unservable = [], []
+    for j in all_jobs:
+        if any(skill_ok(v, j.get("skill")) for v in vehicles):
+            jobs.append(j)
+        else:
+            unservable.append(j["id"])
+    if not jobs:
+        return {"status": "OK", "routes": [], "unassigned": unservable,
+                "total_travel_min": 0, "objective": 0, "solve_ms": 0}
+
+    n_jobs, n_veh = len(jobs), len(vehicles)
+    N = n_jobs + n_veh  # 0..n_jobs-1 = jobs ; n_jobs+v = domicile du véhicule v
+
+    coords = [None] * N
+    for i, j in enumerate(jobs):
+        if j.get("lat") is not None and j.get("lon") is not None:
+            coords[i] = (float(j["lat"]), float(j["lon"]))
+    for v, veh in enumerate(vehicles):
+        if veh.get("home_lat") is not None and veh.get("home_lon") is not None:
+            coords[n_jobs + v] = (float(veh["home_lat"]), float(veh["home_lon"]))
+
+    supplied = req.get("matrix")
+
+    def travel_min(a, b):
+        if supplied is not None:
+            return supplied[a][b]
+        ca, cb = coords[a], coords[b]
+        if ca is None or cb is None:
+            return 0  # coordonnée inconnue → trajet neutre (ne pas pénaliser à tort)
+        return _haversine_km(ca, cb) * 60.0 / speed
+
+    service = [0] * N
+    for i, j in enumerate(jobs):
+        service[i] = int(j.get("service_min") or default_service)
+
+    starts = [n_jobs + v for v in range(n_veh)]
+    manager = pywrapcp.RoutingIndexManager(N, n_veh, starts, starts)  # départ == retour == domicile
+    routing = pywrapcp.RoutingModel(manager)
+
+    # Coût PAR VÉHICULE = trajet + biais spécialiste (rang de la compétence chez CE tech ; 0 = principale).
+    def make_cost_cb(v):
+        vskills = vehicles[v].get("skills") or []
+
+        def cb(fi, ti):
+            f = manager.IndexToNode(fi)
+            t = manager.IndexToNode(ti)
+            base = travel_min(f, t)
+            rank = 0
+            if t < n_jobs:
+                sk = jobs[t].get("skill")
+                if sk and sk in vskills:
+                    rank = vskills.index(sk)
+            return int(round(base + rank * rank_w))
+        return cb
+
+    for v in range(n_veh):
+        cidx = routing.RegisterTransitCallback(make_cost_cb(v))
+        routing.SetArcCostEvaluatorOfVehicle(cidx, v)
+
+    # Dimension TEMPS = trajet + temps sur place du nœud de départ.
+    def time_cb(fi, ti):
+        f = manager.IndexToNode(fi)
+        return int(round(travel_min(f, manager.IndexToNode(ti)) + service[f]))
+    time_idx = routing.RegisterTransitCallback(time_cb)
+
+    horizon = 1440
+    for veh in vehicles:
+        horizon = max(horizon, int(veh.get("shift_end_min") or 0))
+    for j in jobs:
+        if j.get("tw_end_min") is not None:
+            horizon = max(horizon, int(j["tw_end_min"]))
+    routing.AddDimension(time_idx, horizon, horizon, False, "Time")  # slack=horizon (attente permise), start non forcé à 0
+    time_dim = routing.GetDimensionOrDie("Time")
+
+    # Fenêtre de QUART par véhicule (début/fin de tournée dans le quart).
+    for v, veh in enumerate(vehicles):
+        s0 = int(veh.get("shift_start_min") or 0)
+        s1 = int(veh.get("shift_end_min") or horizon)
+        if s1 < s0:
+            s1 = horizon
+        time_dim.CumulVar(routing.Start(v)).SetRange(s0, s1)
+        time_dim.CumulVar(routing.End(v)).SetRange(s0, s1)
+
+    # Fenêtre horaire par job (optionnelle) + compétence (véhicules autorisés) + pénalité de drop.
+    # NB : SetAllowedVehiclesForIndex a un typemap Span cassé en ortools 9.15 → on contraint VehicleVar ∈ autorisés ∪ {-1}
+    # (-1 = job non planifié ; la disjonction le permet).
+    sv = routing.solver()
+    for i, j in enumerate(jobs):
+        idx = manager.NodeToIndex(i)
+        tws, twe = j.get("tw_start_min"), j.get("tw_end_min")
+        if tws is not None and twe is not None and int(twe) >= int(tws):
+            time_dim.CumulVar(idx).SetRange(int(tws), int(twe))
+        sk = j.get("skill")
+        allowed = [v for v, veh in enumerate(vehicles) if skill_ok(veh, sk)]
+        if len(allowed) < n_veh:  # compétence restreint réellement → filtre DUR
+            sv.Add(sv.MemberCt(routing.VehicleVar(idx), allowed + [-1]))
+        routing.AddDisjunction([idx], base_pen + int(j.get("priority_boost") or 0))  # laisser tomber coûte cher → préfère assigner
+
+    params = pywrapcp.DefaultRoutingSearchParameters()
+    params.first_solution_strategy = routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
+    params.local_search_metaheuristic = routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
+    params.time_limit.FromSeconds(max(1, int(max_seconds)))
+    sol = routing.SolveWithParameters(params)
+
+    if sol is None:
+        return {"status": "NO_SOLUTION", "routes": [], "unassigned": [j["id"] for j in jobs] + unservable,
+                "total_travel_min": 0, "objective": None, "solve_ms": 0,
+                "message": "Aucune tournée faisable (fenêtres/quarts trop serrés)."}
+
+    routes = []
+    assigned = set()
+    total_travel = 0
+    for v, veh in enumerate(vehicles):
+        idx = routing.Start(v)
+        stops = []
+        route_travel = 0
+        while not routing.IsEnd(idx):
+            node = manager.IndexToNode(idx)
+            nxt = sol.Value(routing.NextVar(idx))
+            route_travel += int(round(travel_min(node, manager.IndexToNode(nxt))))
+            if node < n_jobs:
+                stops.append({"job_id": jobs[node]["id"],
+                              "arrival_min": int(sol.Value(time_dim.CumulVar(idx))),
+                              "service_min": service[node]})
+                assigned.add(node)
+            idx = nxt
+        if stops:
+            total_travel += route_travel
+            routes.append({"vehicle": veh["id"], "vehicle_name": veh.get("name", veh["id"]),
+                           "stops": stops, "travel_min": int(route_travel)})
+
+    unassigned = [jobs[i]["id"] for i in range(n_jobs) if i not in assigned] + unservable
+    try:
+        solve_ms = int(routing.solver().WallTime())
+    except Exception:
+        solve_ms = None
+    return {
+        "status": "OK",
+        "routes": routes,
+        "unassigned": unassigned,
+        "total_travel_min": int(total_travel),
+        "objective": sol.ObjectiveValue(),
+        "solve_ms": solve_ms,
+    }

services/targo-hub/lib/roster.js

@@ -910,6 +910,14 @@ async function handle (req, res, method, path, url) {
     if (!start) return json(res, 400, { error: 'start requis' })
     return json(res, 200, { capacity: await capacityByDay(start, days), segments: DAY_SEGMENTS })
   }
+  // Optimisation de TOURNÉES (VRPTW + compétences + temps sur place) — proxy vers le solveur OR-Tools /route.
+  // Le SPA construit le payload {jobs, vehicles, ...} (il a coords/skills/durées/domiciles/quarts) ; on relaie au solveur interne.
+  if (path === '/roster/optimize-routes' && method === 'POST') {
+    const body = await parseBody(req)
+    if (!Array.isArray(body.jobs) || !Array.isArray(body.vehicles)) return json(res, 400, { error: 'jobs[] et vehicles[] requis' })
+    try { return json(res, 200, await postSolver('/route', body)) }
+    catch (e) { return json(res, 502, { status: 'ERROR', message: 'solveur injoignable: ' + (e && e.message) }) }
+  }
   // Jours fériés QC (déterministe) — sert le badge « férié » du day-strip + la réduction de capacité par défaut.
   if (path === '/roster/holidays' && method === 'GET') {
     const from = url.searchParams.get('from') || todayET()