M54: harden operations and demo resilience

backend/app/seed_loader.py

@@ -11,6 +11,7 @@ from sqlalchemy import delete, insert, update
 from sqlalchemy.orm import Session
 
 from app.core.config import get_settings
+from app.core.db import begin_exclusive_demo_reset, end_exclusive_demo_reset
 from app.models.audit import AuditEvent
 from app.models.booking import Booking
 from app.models.customer import Customer
@@ -201,7 +202,11 @@ def load_seed(db: Session) -> SeedResult:
     counts["bookings"] = len(booking_rows)
 
     inspection_rows = []
-    for row in _read_csv("inspections.csv"):
+    inspection_source_rows = _read_csv("inspections.csv")
+    return_inspection_row_by_booking_ref = {
+        row["booking_ref"]: row for row in inspection_source_rows if row["type"] == "return"
+    }
+    for row in inspection_source_rows:
         inspection_rows.append(
             {
                 "id": uuid.uuid4(),
@@ -259,16 +264,18 @@ def load_seed(db: Session) -> SeedResult:
         }
 
     def _odometer_regression_signal(later_ref: str, earlier_ref: str) -> list[dict]:
-        later = booking_row_by_ref[later_ref]
-        earlier = booking_row_by_ref[earlier_ref]
+        later = return_inspection_row_by_booking_ref[later_ref]
+        earlier = return_inspection_row_by_booking_ref[earlier_ref]
         return [
             {
                 "code": "odometer.regression",
+                "source_type": "return",
                 "params": {
-                    "later_ref": later_ref,
-                    "later_km": later["end_odometer_km"],
-                    "earlier_ref": earlier_ref,
-                    "earlier_km": earlier["end_odometer_km"],
+                    "later_ref": later["public_ref"],
+                    "later_km": int(later["odometer_km"]),
+                    "earlier_ref": earlier["public_ref"],
+                    "earlier_km": int(earlier["odometer_km"]),
+                    "booking_ref": later_ref,
                 },
             }
         ]
@@ -354,6 +361,27 @@ def load_seed(db: Session) -> SeedResult:
         entity_type, entity_id = resolve_entity(row["entity_ref"])
         related_ref = row.get("related_ref") or ""
         related_refs = related_ref.split("|") if related_ref else []
+        signals = _seed_signals(row["public_ref"], row["entity_ref"], related_refs)
+        evidence_extra: dict[str, object] = {}
+        if row["rule_type"] == "odometer_regression" and signals:
+            params = signals[0].get("params", {})
+            later_ref = params.get("later_ref")
+            earlier_ref = params.get("earlier_ref")
+            booking_ref = params.get("booking_ref")
+            if (
+                isinstance(earlier_ref, str)
+                and isinstance(later_ref, str)
+                and isinstance(booking_ref, str)
+            ):
+                # The authored CSV prose predates structured references. Preserve the
+                # two real source bookings so the detail page can show evidence, while
+                # only the later (regressing) reading is eligible for correction.
+                related_refs = [earlier_ref, booking_ref, later_ref]
+                evidence_extra = {
+                    "source_type": signals[0].get("source_type", "return"),
+                    "source_types": [signals[0].get("source_type", "return")],
+                    "correctable_booking_refs": [booking_ref],
+                }
         severity_due_delta = {
             "high": timedelta(hours=4),
             "medium": timedelta(days=1),
@@ -372,7 +400,8 @@ def load_seed(db: Session) -> SeedResult:
                     "summary": row["evidence"],
                     "entity_ref": row["entity_ref"],
                     "related_refs": related_refs,
-                    "signals": _seed_signals(row["public_ref"], row["entity_ref"], related_refs),
+                    "signals": signals,
+                    **evidence_extra,
                 },
                 "proposed_action_json": {},
                 "detected_at": now,
@@ -449,12 +478,23 @@ def load_seed(db: Session) -> SeedResult:
     return SeedResult(counts=counts, anchor_date=today, seeded_at=seeded_at)
 
 
-def reset_and_seed(db: Session, *, preserve_integration_telemetry: bool = False) -> SeedResult:
+def reset_and_seed(
+    db: Session,
+    *,
+    preserve_integration_telemetry: bool = False,
+    commit: bool = True,
+) -> SeedResult:
     from app.services.data_quality import run_scan
 
+    if not db.info.get("mobilityops_demo_reset_exclusive"):
+        begin_exclusive_demo_reset(db)
     clear_all(db, preserve_integration_telemetry=preserve_integration_telemetry)
     result = load_seed(db)
-    db.commit()
-    scan = run_scan(db)
+    scan = run_scan(db, commit=False)
     result.counts["data_quality_issues"] += sum(scan.created.values())
+    if commit:
+        db.commit()
+        end_exclusive_demo_reset(db)
+    else:
+        db.flush()
     return result