Implement Manticore fully and re-theme

core/presence/engine.py

@@ -2,25 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 
-from django.db import transaction
-
-from core.models import (
-    ContactAvailabilityEvent,
-    ContactAvailabilitySettings,
-    ContactAvailabilitySpan,
-    Person,
-    PersonIdentifier,
-    User,
-)
-
-from .inference import fade_confidence, now_ms, should_fade
-
-POSITIVE_SOURCE_KINDS = {
-    "native_presence",
-    "read_receipt",
-    "typing_start",
-    "message_in",
-}
+from core.models import ContactAvailabilitySettings, Person, PersonIdentifier, User
 
 
 @dataclass(slots=True)
@@ -41,95 +23,24 @@ def get_settings(user: User) -> ContactAvailabilitySettings:
     return settings_row
 
 
-def _normalize_ts(value: int | None) -> int:
-    try:
-        ts = int(value or 0)
-    except Exception:
-        ts = 0
-    return ts if ts > 0 else now_ms()
+def record_native_signal(signal: AvailabilitySignal) -> AvailabilitySignal | None:
+    """
+    Compatibility adapter for existing router call sites.
 
-
-def _upsert_spans_for_event(event: ContactAvailabilityEvent) -> None:
-    prev = (
-        ContactAvailabilitySpan.objects.filter(
-            user=event.user,
-            person=event.person,
-            service=event.service,
-        )
-        .order_by("-end_ts", "-id")
-        .first()
-    )
-
-    if prev and prev.state == event.availability_state:
-        prev.end_ts = max(int(prev.end_ts or 0), int(event.ts or 0))
-        prev.confidence_end = float(event.confidence or 0.0)
-        prev.closing_event = event
-        prev.payload = dict(prev.payload or {})
-        prev.payload.update({"extended_by": str(event.source_kind or "")})
-        prev.save(
-            update_fields=[
-                "end_ts",
-                "confidence_end",
-                "closing_event",
-                "payload",
-                "updated_at",
-            ]
-        )
-        return
-
-    ContactAvailabilitySpan.objects.create(
-        user=event.user,
-        person=event.person,
-        person_identifier=event.person_identifier,
-        service=event.service,
-        state=event.availability_state,
-        start_ts=int(event.ts or 0),
-        end_ts=int(event.ts or 0),
-        confidence_start=float(event.confidence or 0.0),
-        confidence_end=float(event.confidence or 0.0),
-        opening_event=event,
-        closing_event=event,
-        payload=dict(event.payload or {}),
-    )
-
-
-@transaction.atomic
-def record_native_signal(signal: AvailabilitySignal) -> ContactAvailabilityEvent | None:
+    Availability state is now derived from behavioral events in Manticore, so this
+    function no longer persists a separate ORM availability row.
+    """
     settings_row = get_settings(signal.user)
     if not settings_row.enabled:
         return None
-
-    event = ContactAvailabilityEvent.objects.create(
-        user=signal.user,
-        person=signal.person,
-        person_identifier=signal.person_identifier,
-        service=str(signal.service or "").strip().lower() or "signal",
-        source_kind=str(signal.source_kind or "").strip() or "native_presence",
-        availability_state=str(signal.availability_state or "unknown").strip()
-        or "unknown",
-        confidence=float(signal.confidence or 0.0),
-        ts=_normalize_ts(signal.ts),
-        payload=dict(signal.payload or {}),
-    )
-    _upsert_spans_for_event(event)
-    _prune_old_data(signal.user, settings_row.retention_days)
-    return event
+    return signal
 
 
-def record_inferred_signal(
-    signal: AvailabilitySignal,
-) -> ContactAvailabilityEvent | None:
+def record_inferred_signal(signal: AvailabilitySignal) -> AvailabilitySignal | None:
     settings_row = get_settings(signal.user)
     if not settings_row.enabled or not settings_row.inference_enabled:
         return None
-    return record_native_signal(signal)
-
-
-def _prune_old_data(user: User, retention_days: int) -> None:
-    days = max(1, int(retention_days or 90))
-    cutoff = now_ms() - (days * 24 * 60 * 60 * 1000)
-    ContactAvailabilityEvent.objects.filter(user=user, ts__lt=cutoff).delete()
-    ContactAvailabilitySpan.objects.filter(user=user, end_ts__lt=cutoff).delete()
+    return signal
 
 
 def ensure_fading_state(
@@ -139,48 +50,5 @@ def ensure_fading_state(
     person_identifier: PersonIdentifier | None,
     service: str,
     at_ts: int | None = None,
-) -> ContactAvailabilityEvent | None:
-    settings_row = get_settings(user)
-    if not settings_row.enabled or not settings_row.inference_enabled:
-        return None
-
-    current_ts = _normalize_ts(at_ts)
-    latest = (
-        ContactAvailabilityEvent.objects.filter(
-            user=user,
-            person=person,
-            service=str(service or "").strip().lower(),
-        )
-        .order_by("-ts", "-id")
-        .first()
-    )
-    if latest is None:
-        return None
-    if latest.availability_state in {"fading", "unavailable"}:
-        return None
-    if latest.source_kind not in POSITIVE_SOURCE_KINDS:
-        return None
-    if not should_fade(
-        int(latest.ts or 0), current_ts, settings_row.fade_threshold_seconds
-    ):
-        return None
-
-    elapsed = max(0, current_ts - int(latest.ts or 0))
-    payload = {
-        "inferred_from": latest.source_kind,
-        "last_signal_ts": int(latest.ts or 0),
-        "elapsed_ms": elapsed,
-    }
-    return record_inferred_signal(
-        AvailabilitySignal(
-            user=user,
-            person=person,
-            person_identifier=person_identifier,
-            service=service,
-            source_kind="inferred_timeout",
-            availability_state="fading",
-            confidence=fade_confidence(elapsed, settings_row.fade_threshold_seconds),
-            ts=current_ts,
-            payload=payload,
-        )
-    )
+) -> None:
+    return None