Button press should also work

app.py

@@ -196,11 +196,9 @@ SLAM_QUALITY_TIMEOUT_S = 10.0
 # peer overran a 12s lead by ~0.7s (cold boot ≈10.2s, but it only had ~9.5s
 # after poll delivery), so 15s gives ~2.3s margin over the observed cold boot.
 GROUP_START_LEAD_COLD_S = 15.0   # OAK-D likely asleep → cover poll delivery + cold boot
-# Warm: only command delivery to cover, one round-trip on the long-poll (see _enqueue).
+# Warm: only covers command delivery (long-poll, see _enqueue).
 GROUP_START_LEAD_WARM_S = 1.0
-# Fleet button with a member's depth camera still booting: T0 is fixed once every
-# camera reports warm (heartbeat), rather than paying the full cold lead. Past
-# this, give up waiting and start with the cold lead anyway.
+# Max wait for the depth cameras before starting with the cold lead anyway.
 START_WAIT_CAMERA_MAX_S = 20.0
 # Fleet can't see the OAK-D power state directly; it infers "warm" from the time
 # since the session's last recording stop. This window MUST stay safely below
@@ -860,10 +858,9 @@ class Session:
     start_errors: dict[str, str] = field(default_factory=dict)
     # device_id -> epoch of the last depth-camera lease sent (see DEPTH_HOLD_TTL_S).
     depth_hold_sent_at: dict[str, float] = field(default_factory=dict)
-    # Epoch of a fleet-button start waiting for the depth cameras (no T0 yet, see
-    # START_WAIT_CAMERA_MAX_S). None = no start waiting.
+    # Epoch of a start waiting for the depth cameras (no T0 yet).
     start_waiting_since: Optional[float] = None
-    # Why a waiting start could not be launched in the end ("" = none).
+    # Why a waiting start was dropped.
     start_wait_error: str = ""
     # Each entry: {"episode_id": str, "roles": {role: device_id}, "started_at": float}
     episodes: list[dict[str, Any]] = field(default_factory=list)
@@ -1543,8 +1540,7 @@ async def list_devices(request: Request) -> dict[str, Any]:
                 # Why this device refuses to record ("" = healthy). Separate from
                 # activity: a device can be both faulted and busy.
                 "hardware_error": d.hardware_error,
-                # Depth camera warm (None = not reported): drives the session's
-                # "camera is initializing" note.
+                # None = not reported.
                 "depth_warm": d.depth_warm,
                 # id of the dataset build this device is working for ("" = none):
                 # what the fleet list's Cancel button acts on.
@@ -2574,7 +2570,7 @@ def _get_open_session(owner: str, session_id: str) -> Session:
 
 
 def _start_session_episode(owner: str, s: Session) -> tuple[str, str]:
-    """Schedule the fleet-button episode now. Returns (T0 iso, episode_id)."""
+    """Returns (T0 iso, episode_id)."""
     s.start_waiting_since = None
     _task = _tasks_of(owner).get(s.task_id)
     target_iso = _schedule_episode_start(
@@ -2593,8 +2589,7 @@ def _start_session_episode(owner: str, s: Session) -> tuple[str, str]:
 
 
 def _should_wait_for_cameras(owner: str, s: Session) -> bool:
-    """Wait only if a camera is cold AND every member will report when it is
-    warm (hold capability) — otherwise nothing would ever end the wait."""
+    """Only members with the hold report warm, so only they can end a wait."""
     fleet = _fleet_of(owner)
     devs = [fleet.get(d) for d in s.members.values()]
     if any(d is None or DEPTH_HOLD_CAPABILITY not in d.capabilities for d in devs):
@@ -2603,8 +2598,7 @@ def _should_wait_for_cameras(owner: str, s: Session) -> bool:
 
 
 def _launch_waiting_start(owner: str, dev: Device) -> None:
-    """Called on every heartbeat: launch dev's session's waiting start once every
-    camera is warm, or with the cold lead once the wait has run too long."""
+    """On heartbeat: launch a waiting start once the cameras are warm."""
     s = _open_session_for_device(owner, dev.device_id)
     if s is None or s.start_waiting_since is None:
         return
@@ -2615,7 +2609,7 @@ def _launch_waiting_start(owner: str, dev: Device) -> None:
         _raise_if_recording_blocked(owner, s.members.values())
         _start_session_episode(owner, s)
     except HTTPException as e:
-        # Went offline / faulted / busy while waiting: drop the start and say so.
+        # A member went offline / faulted / busy meanwhile.
         s.start_waiting_since = None
         detail = e.detail if isinstance(e.detail, dict) else {"message": str(e.detail)}
         s.start_wait_error = str(detail.get("message") or "start failed")
@@ -2632,7 +2626,7 @@ async def session_episode_start(session_id: str, request: Request) -> dict[str,
     _raise_if_recording_blocked(owner, s.members.values())
     s.start_wait_error = ""
     if _should_wait_for_cameras(owner, s):
-        # Offline / faulted members are refused now, not after the wait.
+        # Refuse now rather than after the wait.
         _raise_if_start_refused(owner, s.members)
         s.start_waiting_since = time.time()
         return {"status": "waiting_camera", "devices": list(s.members.values())}
@@ -2646,7 +2640,7 @@ async def session_episode_stop(session_id: str, request: Request) -> dict[str, A
     owner = await _operator_loaded(request)
     s = _get_open_session(owner, session_id)
     if s.start_waiting_since is not None and not s.recording:
-        # Cancelled before any T0: nothing was dispatched, nothing to stop.
+        # No T0 yet: nothing to stop.
         s.start_waiting_since = None
         return {"status": "ok", "devices": list(s.members.values())}
     ids = _dispatch_episode_stop(owner, s.members)
@@ -3543,9 +3537,17 @@ async def start_slam_check(req: SlamCheckReq, request: Request) -> dict[str, Any
 # device (found by membership). It behaves exactly like the operator starting
 # an episode from the dashboard: same task, same synchronized T0 across the
 # session's members. No open session → solo (the device records locally). ======
+class SyncStartReq(BaseModel):
+    task_name: str = ""
+    # Older firmware would record solo on "waiting_camera".
+    can_wait: bool = False
+
+
 @app.post("/api/devices/{device_id}/sync/start")
-async def device_sync_start(device_id: str, auth: tuple[str, str] = Depends(device_auth)) -> dict[str, Any]:
+async def device_sync_start(device_id: str, req: Optional[SyncStartReq] = None,
+                            auth: tuple[str, str] = Depends(device_auth)) -> dict[str, Any]:
     owner, _token = auth
+    can_wait = req is not None and req.can_wait
     if device_id not in _fleet_of(owner):
         raise HTTPException(404, "Device not registered")
     s = _open_session_for_device(owner, device_id)
@@ -3558,8 +3560,14 @@ async def device_sync_start(device_id: str, auth: tuple[str, str] = Depends(devi
     # busy peer refuses its own start_capture locally. A 409 travels back as
     # "refused", which the device turns into an error buzz and no recording.
     _raise_if_recording_blocked(owner, s.members.values())
-    # The physical button takes over a start still waiting for the cameras: it
-    # can't wait itself (it needs T0 in this response), so it pays the cold lead.
+    if can_wait and (s.start_waiting_since is not None or _should_wait_for_cameras(owner, s)):
+        # The presser gets its start_capture like a peer.
+        if s.start_waiting_since is None:
+            _raise_if_start_refused(owner, s.members)
+            s.start_waiting_since = time.time()
+            s.start_wait_error = ""
+        return {"status": "waiting_camera"}
+    # Older firmware needs T0 now: cold lead.
     s.start_waiting_since = None
     s.start_wait_error = ""
     task_name = _task_name(owner, s.task_id)
@@ -3589,7 +3597,10 @@ async def device_sync_stop(device_id: str, auth: tuple[str, str] = Depends(devic
     s = _open_session_for_device(owner, device_id)
     if s is None:
         return {"status": "solo"}
-    s.start_waiting_since = None
+    if s.start_waiting_since is not None and not s.recording:
+        # No T0 yet: nothing to stop.
+        s.start_waiting_since = None
+        return {"status": "ok", "peers": []}
     ids = _dispatch_episode_stop(owner, s.members, exclude_device_id=device_id)
     _begin_episode_stop(s, ids)
     return {"status": "ok", "peers": [d for d in s.members.values() if d != device_id]}
@@ -3980,7 +3991,7 @@ _INDEX = """<!DOCTYPE html><html lang="en"><head><meta charset="utf-8">
  /* record circle blocked because a member is busy with a dataset job */
  .rec-toggle.blocked{cursor:not-allowed;opacity:.4;border-color:rgba(255,255,255,.3)}
  .sp-busy-note{margin-top:.6rem;text-align:center;font-size:.8rem;color:#d6c9fb}
- /* a member's depth camera is still booting: the next start pays the cold boot */
+ /* depth camera still booting */
  .sp-depth-note{margin-top:.6rem;display:flex;align-items:center;gap:.6rem;
   font-size:.85rem;font-weight:600;color:#fcd34d;line-height:1.4;
   background:rgba(245,158,11,.14);border:1px solid rgba(251,191,36,.45);
@@ -4467,8 +4478,7 @@ function activityBadge(id){
 // calibration, no angle sensors). Shown next to the activity badge rather than
 // instead of it — a faulted grabette can also be uploading, and hiding either
 // fact behind the other is how you go hunting for the wrong problem.
-// Depth camera still booting under the session's hold: the first start pays the
-// cold boot (long lead). Only devices that take the hold report this.
+// Only devices with the hold report depth_warm.
 function deviceDepthCold(id){const d=DEVICES.find(x=>x.device_id===id);
  return !!(d&&d.online&&(d.capabilities||[]).includes('hold_depth_camera')&&d.depth_warm!==true);}
 function sessionDepthCold(s){return Object.values(s.members).some(m=>deviceDepthCold(m.device_id));}
@@ -5398,7 +5408,7 @@ async function deleteSession(id){if(!confirm('Delete this session and its manife
 // stopping is reported by the fleet and ends when the devices actually finish
 // (s.stopping is cleared as each stop_capture reports its result).
 function sessionPhase(s){
- if(s.start_waiting)return 'initializing';  // no T0 yet: waiting for the cameras
+ if(s.start_waiting)return 'initializing';  // no T0 yet
  if(s.recording){
   const ep=(s.episodes&&s.episodes.length)?s.episodes[s.episodes.length-1]:null;
   const t0=ep&&ep.start_at_utc?Date.parse(ep.start_at_utc):0;
@@ -5901,7 +5911,6 @@ function renderSessionList(){
   const circTitle=faultBlocked?'A device cannot record — see the fault below'
    :recBlocked?`A device is busy ${busyWhat} — wait for it to finish`:M.title;
   const circle=`<div class="sp-rec"><button class="rec-toggle ${M.btn}${recBlocked?' blocked':''}" ${circDis} title="${circTitle}" onclick='episodeToggle("${s.id}")'><span class="rt-inner"></span></button></div>`;
-  // Kept through "initializing": that is exactly when the operator waits on it.
   const depthCold=((p==='idle'&&!recBlocked)||p==='initializing')&&sessionDepthCold(s);
   const depthNote=depthCold?'<div class="sp-depth-note"><span class="sp-spinner"></span><span>Camera is currently initializing. First recording may take longer to start.</span></div>':'';
   const busyNote=(recBlocked&&!faultBlocked)?`<div class="sp-busy-note">${busyMembers.map(deviceName).join(', ')} busy ${busyWhat} — recording paused until it finishes.</div>`:'';

tests/test_start_wait_camera.py

@@ -120,3 +120,59 @@ def test_member_lost_while_waiting_drops_start_with_error():
     assert s.start_waiting_since is None and s.recording is False
     assert not starts(left)
     assert app._session_dict(OWNER, s)["start_wait_error"]
+
+
+def press(device_id, can_wait=True):
+    req = app.SyncStartReq(can_wait=can_wait)
+    return asyncio.run(app.device_sync_start(device_id, req, auth=(OWNER, "token")))
+
+
+def press_stop(device_id):
+    return asyncio.run(app.device_sync_stop(device_id, auth=(OWNER, "token")))
+
+
+def test_button_waits_then_starts_every_member_including_presser():
+    left, right = fleet()
+    s = launch()
+    left.depth_warm, right.depth_warm = True, False
+
+    assert press(LEFT)["status"] == "waiting_camera"
+    assert not starts(left) and not starts(right)
+
+    beat(RIGHT, depth_warm=True)
+    assert len(starts(left)) == len(starts(right)) == 1
+    assert lead_of(left) <= app.GROUP_START_LEAD_WARM_S
+
+
+def test_old_firmware_button_keeps_cold_lead():
+    left, right = fleet()
+    s = launch()
+    left.depth_warm, right.depth_warm = True, False
+
+    res = press(LEFT, can_wait=False)
+    assert res["status"] == "scheduled"
+    assert not starts(left)  # the presser self-schedules from the response
+    assert lead_of(right) > app.GROUP_START_LEAD_WARM_S
+
+
+def test_button_joins_a_waiting_fleet_start():
+    left, right = fleet()
+    s = launch()
+    left.depth_warm, right.depth_warm = True, False
+    start(s)
+
+    assert press(LEFT)["status"] == "waiting_camera"
+    assert s.start_waiting_since is not None
+
+
+def test_button_stop_while_waiting_cancels_without_stops():
+    left, right = fleet()
+    s = launch()
+    left.depth_warm, right.depth_warm = True, False
+    press(LEFT)
+
+    press_stop(LEFT)
+    assert s.start_waiting_since is None and s.stopping is False
+    beat(RIGHT, depth_warm=True)
+    assert not starts(left) and not starts(right)
+    assert not [c for c in right.queue if c.type == "stop_capture"]