fix timers

backend/app/api/routes_timer.py

@@ -63,11 +63,18 @@ def resume(session: DbSession, settings: Settings) -> dict:
 @router.post("/complete")
 def complete(body: CompleteTimerRequest, session: DbSession, settings: Settings) -> dict:
     try:
-        finished, follow_on = pomodoro.complete(session, settings, auto_next=body.auto_next)
+        finished, follow_on = pomodoro.complete(
+            session,
+            settings,
+            auto_next=body.auto_next,
+            expect_id=body.session_id,
+        )
     except pomodoro.TimerError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
 
-    celebration = _maybe_celebrate(session, settings) if finished.is_work else None
+    # `finished` is None when the named interval was no longer the running one:
+    # nothing happened, so there is nothing to celebrate and nothing to announce.
+    celebration = _maybe_celebrate(session, settings) if finished and finished.is_work else None
     state = pomodoro.state(session, settings)
     state["finished"] = pomodoro.session_dict(finished)
     state["auto_started"] = pomodoro.session_dict(follow_on)

backend/app/api/schemas.py

@@ -29,6 +29,16 @@ class AttachTaskRequest(BaseModel):
 
 class CompleteTimerRequest(BaseModel):
     auto_next: bool = True
+    session_id: int | None = None
+    """Which interval the client believes it is finishing.
+
+    Every client ticks its own local countdown and calls `complete` when it
+    reaches zero, so with two of them open (the phone and the desktop, say)
+    both fire within the same second. Unconditionally, the second call lands
+    on whatever `auto_next` has just started and ends *that* — which is why a
+    break could vanish the instant it began. Sent along, a stale call is a
+    no-op instead. Omitted, the old unconditional behaviour stands.
+    """
 
 
 class TaskCreateRequest(BaseModel):

backend/app/services/pomodoro.py

@@ -176,10 +176,28 @@ def resume(session: Session) -> PomodoroSession:
 
 
 def complete(
-    session: Session, settings: AppSettings, *, auto_next: bool = True
-) -> tuple[PomodoroSession, PomodoroSession | None]:
-    """Finish the current interval and, if configured, roll into the next one."""
-    row = _require_active(session)
+    session: Session,
+    settings: AppSettings,
+    *,
+    auto_next: bool = True,
+    expect_id: int | None = None,
+) -> tuple[PomodoroSession | None, PomodoroSession | None]:
+    """Finish the current interval and, if configured, roll into the next one.
+
+    `expect_id` is the interval the caller believes it is finishing. Every
+    client runs its own local countdown and calls this when it hits zero, so
+    two clients open at once both call within the same second — and the second
+    call used to land on the interval `auto_next` had just created and end it
+    immediately. That is a break disappearing the moment it starts, and it is
+    not something a client can fix on its own: only the server knows which
+    interval is current. So a call that names an interval which is no longer
+    running does nothing at all, and says so by returning no `finished`.
+    """
+    row = current_session(session)
+    if expect_id is not None and (row is None or row.id != expect_id):
+        return None, None
+    if row is None:
+        raise TimerError("No interval is running.")
     finished = _finish(session, settings, row, status="completed")
 
     follow_on: PomodoroSession | None = None