Merge branch 'main' into brady-bunch-sync

.gitleaksignore

@@ -4,4 +4,4 @@ docs/docs/installation/daily-setup.md:curl-auth-header:277
 gpu/self_hosted/DEV_SETUP.md:curl-auth-header:74
 gpu/self_hosted/DEV_SETUP.md:curl-auth-header:83
 server/reflector/worker/process.py:generic-api-key:465
-server/reflector/worker/process.py:generic-api-key:594
+server/tests/test_recording_request_flow.py:generic-api-key:121

CHANGELOG.md

@@ -1,14 +1,5 @@
 # Changelog
 
-## [0.32.2](https://github.com/Monadical-SAS/reflector/compare/v0.32.1...v0.32.2) (2026-02-03)
-
-
-### Bug Fixes
-
-* increase TIMEOUT_MEDIUM from 2m to 5m for LLM tasks ([#843](https://github.com/Monadical-SAS/reflector/issues/843)) ([4acde4b](https://github.com/Monadical-SAS/reflector/commit/4acde4b7fdef88cc02ca12cf38c9020b05ed96ac))
-* make caddy optional ([#841](https://github.com/Monadical-SAS/reflector/issues/841)) ([a2ed7d6](https://github.com/Monadical-SAS/reflector/commit/a2ed7d60d557b551a5b64e4dfd909b63a791d9fc))
-* use Daily API recording.duration as master source for transcript duration ([#844](https://github.com/Monadical-SAS/reflector/issues/844)) ([8707c66](https://github.com/Monadical-SAS/reflector/commit/8707c6694a80c939b6214bbc13331741f192e082))
-
 ## [0.32.1](https://github.com/Monadical-SAS/reflector/compare/v0.32.0...v0.32.1) (2026-01-30)
 
 

gpu/self_hosted/Dockerfile

@@ -4,31 +4,27 @@ ENV PYTHONUNBUFFERED=1 \
     UV_LINK_MODE=copy \
     UV_NO_CACHE=1
 
-# patch until nvidia updates the sha1 repo
-ADD sequoia.config /etc/crypto-policies/back-ends/sequoia.config
-
 WORKDIR /tmp
-RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
- --mount=type=cache,target=/var/lib/apt,sharing=locked \
- apt-get update \
+RUN apt-get update \
  && apt-get install -y \
     ffmpeg \
     curl \
     ca-certificates \
     gnupg \
-    wget
+    wget \
+ && apt-get clean
 # Add NVIDIA CUDA repo for Debian 12 (bookworm) and install cuDNN 9 for CUDA 12
 ADD https://developer.download.nvidia.com/compute/cuda/repos/debian12/x86_64/cuda-keyring_1.1-1_all.deb /cuda-keyring.deb
-RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
- --mount=type=cache,target=/var/lib/apt,sharing=locked \
- dpkg -i /cuda-keyring.deb \
+RUN dpkg -i /cuda-keyring.deb \
  && rm /cuda-keyring.deb \
  && apt-get update \
  && apt-get install -y --no-install-recommends \
     cuda-cudart-12-6 \
     libcublas-12-6 \
     libcudnn9-cuda-12 \
-    libcudnn9-dev-cuda-12
+    libcudnn9-dev-cuda-12 \
+ && apt-get clean \
+ && rm -rf /var/lib/apt/lists/*
 ADD https://astral.sh/uv/install.sh /uv-installer.sh
 RUN sh /uv-installer.sh && rm /uv-installer.sh
 ENV PATH="/root/.local/bin/:$PATH"
@@ -43,13 +39,6 @@ COPY ./app /app/app
 COPY ./main.py /app/
 COPY ./runserver.sh /app/
 
-# prevent uv failing with too many open files on big cpus
-ENV UV_CONCURRENT_INSTALLS=16
-
-# first install
-RUN --mount=type=cache,target=/root/.cache/uv \
-    uv sync --compile-bytecode --locked
-
 EXPOSE 8000
 
 CMD ["sh", "/app/runserver.sh"]

gpu/self_hosted/sequoia.config

@@ -1,2 +0,0 @@
-[hash_algorithms]
-sha1 = "always"

server/docs/DAILY_REFLECTOR_DATA_MODEL.md

@@ -86,7 +86,7 @@ Daily.co Room: "daily-private-igor-20260110042117"
 | **Purpose** | Tracks active session state | Links recordings, transcripts, participants |
 | **Scope** | Per room instance | Per Reflector room + timestamp |
 
-**Critical Limitation:** Daily.co's recordings API often does NOT return `mtgSessionId`, requiring time-based matching (see [Time-Based Matching](#time-based-matching)).
+**Critical Limitation:** Daily.co's recordings API often does NOT return `mtgSessionId` (can be null), requiring time-based matching (see [Time-Based Matching](#time-based-matching)).
 
 ### Recording
 
@@ -101,6 +101,30 @@ Daily.co Room: "daily-private-igor-20260110042117"
 
 **Critical Behavior:** Recording **stops/restarts** create **separate recording objects** with unique IDs.
 
+### instanceId (Reflector-Generated)
+
+**Definition:** UUID we generate and send when starting recording via REST API.
+
+**Generation:** Deterministic from meeting_id
+- Cloud: `instanceId = meeting_id` directly
+- Raw-tracks: `instanceId = UUIDv5(meeting_id, namespace)`
+
+**Key behaviors:**
+- ✅ **Reuse allowed:** Same instanceId can be used after stop (validated 2026-01-20)
+- ❌ **Not returned:** Daily.co does NOT echo instanceId back in GET /recordings response
+- ✅ **Present in error webhooks:** `recording.error` webhook includes instanceId
+- **Purpose:** Allows multiple concurrent recordings (cloud + raw-tracks) in same room
+
+**Stop/restart example:**
+```
+Recording 1: POST /start with instanceId="779e6376..." → recording_id="ee00c4e8..."
+Stop recording
+Recording 2: POST /start with instanceId="779e6376..." (SAME) → recording_id="b702f509..." (DIFFERENT)
+✅ Both succeed, different recording_ids returned
+```
+
+**Implication:** Cannot match recordings by instanceId (not in response) - must use recording_id.
+
 ---
 
 ## Entity Relationships
@@ -196,6 +220,19 @@ Daily.co Room: "daily-private-igor-20260110042117"
 
 `mtgSessionId` identifies a **Daily.co meeting session** (not individual participants, not a room).
 
+**Reliability:** Can be null or present in GET /recordings response (unreliable).
+
+**When present:** Multiple recordings from same session (stop/restart with participants connected) share same mtgSessionId.
+
+**Example (validated 2026-01-20):**
+```json
+Recording 1: {"id": "ee00c4e8...", "mtgSessionId": "92c4136a-a8da-41c5-9c45-e9a2baae6bd6"}
+Recording 2: {"id": "b702f509...", "mtgSessionId": "92c4136a-a8da-41c5-9c45-e9a2baae6bd6"}
+// Same mtgSessionId (stop/restart in same session)
+```
+
+**When null:** Common - Daily.co API does not reliably populate this field.
+
 ### session_id (Per-Participant)
 
 **Different concept:** Per-participant connection identifier from webhooks.
@@ -220,16 +257,24 @@ TABLE daily_participant_session (
 
 Daily.co's recordings API does not reliably return `mtgSessionId`, making it impossible to directly link recordings to meetings via Daily.co's identifiers.
 
-**Example API response:**
+**Example API response (mtgSessionId can be null OR present):**
 ```json
 {
   "id": "recording-uuid",
   "room_name": "daily-private-igor-20260110042117",
   "start_ts": 1768018896,
-  "mtgSessionId": null  ← Missing!
+  "mtgSessionId": null  // ← Often null (unreliable)
+}
+
+// OR (when present):
+{
+  "id": "recording-uuid",
+  "mtgSessionId": "92c4136a-a8da-41c5-9c45-e9a2baae6bd6"  // ← Sometimes present
 }
 ```
 
+**Key insight:** Cannot rely on mtgSessionId for matching (unreliable). instanceId also not returned. Only reliable identifier is recording.id.
+
 ### Solution: Time-Based Matching
 
 **Implementation:** `reflector/db/meetings.py:get_by_room_name_and_time()`
@@ -491,6 +536,10 @@ UI: User sees 3 separate transcripts
 
 
 ---
-**Document Version:** 1.0
-**Last Verified:** 2026-01-15
-**Data Source:** Production database + Daily.co API inspection
+**Document Version:** 1.1
+**Last Updated:** 2026-01-20
+**Data Source:** Production database + Daily.co API inspection + empirical testing
+**Changes in 1.1:**
+- Added instanceId behavior documentation (reuse allowed, not returned in API)
+- Clarified mtgSessionId reliability (can be null or present)
+- Added empirical validation of stop/restart behavior

server/migrations/versions/f5b008fa8a14_add_daily_recording_requests.py

@@ -0,0 +1,67 @@
+"""add_daily_recording_requests
+
+Revision ID: f5b008fa8a14
+Revises: 1b1e6a6fc465
+Create Date: 2026-01-20 22:32:06.697144
+
+"""
+
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "f5b008fa8a14"
+down_revision: Union[str, None] = "1b1e6a6fc465"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "daily_recording_request",
+        sa.Column("recording_id", sa.String(), nullable=False),
+        sa.Column("meeting_id", sa.String(), nullable=False),
+        sa.Column("instance_id", sa.String(), nullable=False),
+        sa.Column("type", sa.String(), nullable=False),
+        sa.Column("requested_at", sa.DateTime(timezone=True), nullable=False),
+        sa.ForeignKeyConstraint(["meeting_id"], ["meeting.id"], ondelete="CASCADE"),
+        sa.PrimaryKeyConstraint("recording_id"),
+    )
+    op.create_index("idx_meeting_id", "daily_recording_request", ["meeting_id"])
+    op.create_index("idx_instance_id", "daily_recording_request", ["instance_id"])
+
+    # Clean up orphaned recordings before adding FK constraint
+    op.execute("""
+        UPDATE recording SET status = 'orphan', meeting_id = NULL
+        WHERE meeting_id IS NOT NULL
+        AND meeting_id NOT IN (SELECT id FROM meeting)
+    """)
+
+    # Add FK constraint to recording table (cascade delete recordings when meeting deleted)
+    op.execute("""
+        ALTER TABLE recording ADD CONSTRAINT fk_recording_meeting
+          FOREIGN KEY (meeting_id) REFERENCES meeting(id) ON DELETE CASCADE
+    """)
+
+    # Add CHECK constraints to enforce orphan invariants
+    op.execute("""
+        ALTER TABLE recording ADD CONSTRAINT chk_orphan_no_meeting
+          CHECK (status != 'orphan' OR meeting_id IS NULL)
+    """)
+    op.execute("""
+        ALTER TABLE recording ADD CONSTRAINT chk_non_orphan_has_meeting
+          CHECK (status = 'orphan' OR meeting_id IS NOT NULL)
+    """)
+
+
+def downgrade() -> None:
+    op.execute("ALTER TABLE recording DROP CONSTRAINT IF EXISTS chk_orphan_no_meeting")
+    op.execute(
+        "ALTER TABLE recording DROP CONSTRAINT IF EXISTS chk_non_orphan_has_meeting"
+    )
+    op.execute("ALTER TABLE recording DROP CONSTRAINT IF EXISTS fk_recording_meeting")
+    op.drop_index("idx_instance_id", table_name="daily_recording_request")
+    op.drop_index("idx_meeting_id", table_name="daily_recording_request")
+    op.drop_table("daily_recording_request")

server/reflector/dailyco_api/recording_orphans.py

@@ -0,0 +1,56 @@
+"""Utility for creating orphan recordings."""
+
+import os
+from datetime import datetime, timezone
+
+from reflector.db.recordings import Recording, recordings_controller
+from reflector.logger import logger
+from reflector.utils.string import NonEmptyString
+
+
+async def create_and_log_orphan(
+    recording_id: NonEmptyString,
+    bucket_name: str,
+    room_name: str,
+    start_ts: int,
+    track_keys: list[str] | None,
+    source: str,
+) -> bool:
+    """Create orphan recording and log if first occurrence.
+
+    Args:
+        recording_id: Daily.co recording ID
+        bucket_name: S3 bucket (empty string for cloud recordings)
+        room_name: Daily.co room name
+        start_ts: Unix timestamp
+        track_keys: Track keys for raw-tracks, None for cloud
+        source: "webhook" or "polling" for logging
+
+    Returns:
+        True if created (first poller), False if already exists
+    """
+    if track_keys:
+        object_key = os.path.dirname(track_keys[0]) if track_keys else room_name
+    else:
+        object_key = room_name
+
+    created = await recordings_controller.create_orphan(
+        Recording(
+            id=recording_id,
+            bucket_name=bucket_name,
+            object_key=object_key,
+            recorded_at=datetime.fromtimestamp(start_ts, tz=timezone.utc),
+            track_keys=track_keys,
+            meeting_id=None,
+            status="orphan",
+        )
+    )
+
+    if created:
+        logger.error(
+            f"Orphan recording ({source})",
+            recording_id=recording_id,
+            room_name=room_name,
+        )
+
+    return created

server/reflector/db/__init__.py

@@ -26,6 +26,7 @@ def get_database() -> databases.Database:
 # import models
 import reflector.db.calendar_events  # noqa
 import reflector.db.daily_participant_sessions  # noqa
+import reflector.db.daily_recording_requests  # noqa
 import reflector.db.meetings  # noqa
 import reflector.db.recordings  # noqa
 import reflector.db.rooms  # noqa

server/reflector/db/daily_recording_requests.py

@@ -0,0 +1,111 @@
+from datetime import datetime
+from typing import Literal
+from uuid import UUID
+
+import sqlalchemy as sa
+from pydantic import BaseModel
+from sqlalchemy.dialects.postgresql import insert
+
+from reflector.db import get_database, metadata
+from reflector.utils.string import NonEmptyString
+
+daily_recording_requests = sa.Table(
+    "daily_recording_request",
+    metadata,
+    sa.Column("recording_id", sa.String, primary_key=True),
+    sa.Column(
+        "meeting_id",
+        sa.String,
+        sa.ForeignKey("meeting.id", ondelete="CASCADE"),
+        nullable=False,
+    ),
+    sa.Column("instance_id", sa.String, nullable=False),
+    sa.Column("type", sa.String, nullable=False),
+    sa.Column("requested_at", sa.DateTime(timezone=True), nullable=False),
+    sa.Index("idx_meeting_id", "meeting_id"),
+    sa.Index("idx_instance_id", "instance_id"),
+)
+
+
+class DailyRecordingRequest(BaseModel):
+    recording_id: NonEmptyString
+    meeting_id: NonEmptyString
+    instance_id: UUID
+    type: Literal["cloud", "raw-tracks"]
+    requested_at: datetime
+
+
+class DailyRecordingRequestsController:
+    async def create(self, request: DailyRecordingRequest) -> None:
+        stmt = insert(daily_recording_requests).values(
+            recording_id=request.recording_id,
+            meeting_id=request.meeting_id,
+            instance_id=str(request.instance_id),
+            type=request.type,
+            requested_at=request.requested_at,
+        )
+        stmt = stmt.on_conflict_do_nothing(index_elements=["recording_id"])
+        await get_database().execute(stmt)
+
+    async def find_by_recording_id(
+        self,
+        recording_id: NonEmptyString,
+    ) -> tuple[NonEmptyString, Literal["cloud", "raw-tracks"]] | None:
+        query = daily_recording_requests.select().where(
+            daily_recording_requests.c.recording_id == recording_id
+        )
+        result = await get_database().fetch_one(query)
+
+        if not result:
+            return None
+
+        req = DailyRecordingRequest(
+            recording_id=result["recording_id"],
+            meeting_id=result["meeting_id"],
+            instance_id=UUID(result["instance_id"]),
+            type=result["type"],
+            requested_at=result["requested_at"],
+        )
+        return (req.meeting_id, req.type)
+
+    async def find_by_instance_id(
+        self,
+        instance_id: UUID,
+    ) -> list[DailyRecordingRequest]:
+        """Multiple recordings can have same instance_id (stop/restart)."""
+        query = daily_recording_requests.select().where(
+            daily_recording_requests.c.instance_id == str(instance_id)
+        )
+        results = await get_database().fetch_all(query)
+        return [
+            DailyRecordingRequest(
+                recording_id=r["recording_id"],
+                meeting_id=r["meeting_id"],
+                instance_id=UUID(r["instance_id"]),
+                type=r["type"],
+                requested_at=r["requested_at"],
+            )
+            for r in results
+        ]
+
+    async def get_by_meeting_id(
+        self,
+        meeting_id: NonEmptyString,
+    ) -> list[DailyRecordingRequest]:
+        query = daily_recording_requests.select().where(
+            daily_recording_requests.c.meeting_id == meeting_id
+        )
+        results = await get_database().fetch_all(query)
+        return [
+            DailyRecordingRequest(
+                recording_id=r["recording_id"],
+                meeting_id=r["meeting_id"],
+                instance_id=UUID(r["instance_id"]),
+                type=r["type"],
+                requested_at=r["requested_at"],
+            )
+            for r in results
+        ]
+
+
+daily_recording_requests_controller = DailyRecordingRequestsController()

server/reflector/db/meetings.py

@@ -1,4 +1,4 @@
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Any, Literal
 
 import sqlalchemy as sa
@@ -183,84 +183,6 @@ class MeetingController:
         results = await get_database().fetch_all(query)
         return [Meeting(**r) for r in results]
 
-    async def get_by_room_name_and_time(
-        self,
-        room_name: NonEmptyString,
-        recording_start: datetime,
-        time_window_hours: int = 168,
-    ) -> Meeting | None:
-        """
-        Get meeting by room name closest to recording timestamp.
-
-        HACK ALERT: Daily.co doesn't return instanceId in recordings API response,
-        and mtgSessionId is separate from our instanceId. Time-based matching is
-        the least-bad workaround.
-
-        This handles edge case of duplicate room_name values in DB (race conditions,
-        double-clicks, etc.) by matching based on temporal proximity.
-
-        Algorithm:
-        1. Find meetings within time_window_hours of recording_start
-        2. Return meeting with start_date closest to recording_start
-        3. If tie, return first by meeting.id (deterministic)
-
-        Args:
-            room_name: Daily.co room name from recording
-            recording_start: Timezone-aware datetime from recording.start_ts
-            time_window_hours: Search window (default 168 = 1 week)
-
-        Returns:
-            Meeting closest to recording timestamp, or None if no matches
-
-        Failure modes:
-        - Multiple meetings in same room within ~5 minutes: picks closest
-        - All meetings outside time window: returns None
-        - Clock skew between Daily.co and DB: 1-week window tolerates this
-
-        Why 1 week window:
-        - Handles webhook failures (recording discovered days later)
-        - Tolerates clock skew
-        - Rejects unrelated meetings from weeks ago
-
-        """
-        # Validate timezone-aware datetime
-        if recording_start.tzinfo is None:
-            raise ValueError(
-                f"recording_start must be timezone-aware, got naive datetime: {recording_start}"
-            )
-
-        window_start = recording_start - timedelta(hours=time_window_hours)
-        window_end = recording_start + timedelta(hours=time_window_hours)
-
-        query = (
-            meetings.select()
-            .where(
-                sa.and_(
-                    meetings.c.room_name == room_name,
-                    meetings.c.start_date >= window_start,
-                    meetings.c.start_date <= window_end,
-                )
-            )
-            .order_by(meetings.c.start_date)
-        )
-
-        results = await get_database().fetch_all(query)
-        if not results:
-            return None
-
-        candidates = [Meeting(**r) for r in results]
-
-        # Find meeting with start_date closest to recording_start
-        closest = min(
-            candidates,
-            key=lambda m: (
-                abs((m.start_date - recording_start).total_seconds()),
-                m.id,  # Tie-breaker: deterministic by UUID
-            ),
-        )
-
-        return closest
-
     async def get_active(self, room: Room, current_time: datetime) -> Meeting | None:
         """
         Get latest active meeting for a room.
@@ -346,69 +268,10 @@ class MeetingController:
             return None
         return Meeting(**result)
 
-    async def get_by_room_and_time_window(
-        self, room: Room, start_date: datetime, end_date: datetime
-    ) -> Meeting | None:
-        """Check if a meeting already exists for this room with the same time window."""
-        query = (
-            meetings.select()
-            .where(
-                sa.and_(
-                    meetings.c.room_id == room.id,
-                    meetings.c.start_date == start_date,
-                    meetings.c.end_date == end_date,
-                    meetings.c.is_active,
-                )
-            )
-            .limit(1)
-        )
-        result = await get_database().fetch_one(query)
-        if not result:
-            return None
-        return Meeting(**result)
-
     async def update_meeting(self, meeting_id: str, **kwargs):
         query = meetings.update().where(meetings.c.id == meeting_id).values(**kwargs)
         await get_database().execute(query)
 
-    async def set_cloud_recording_if_missing(
-        self,
-        meeting_id: NonEmptyString,
-        s3_key: NonEmptyString,
-        duration: int,
-    ) -> bool:
-        """
-        Set cloud recording only if not already set.
-
-        Returns True if updated, False if already set.
-        Prevents webhook/polling race condition via atomic WHERE clause.
-        """
-        # Check current value before update to detect actual change
-        meeting_before = await self.get_by_id(meeting_id)
-        if not meeting_before:
-            return False
-
-        was_null = meeting_before.daily_composed_video_s3_key is None
-
-        query = (
-            meetings.update()
-            .where(
-                sa.and_(
-                    meetings.c.id == meeting_id,
-                    meetings.c.daily_composed_video_s3_key.is_(None),
-                )
-            )
-            .values(
-                daily_composed_video_s3_key=s3_key,
-                daily_composed_video_duration=duration,
-            )
-        )
-        await get_database().execute(query)
-
-        # Return True only if value was NULL before (actual update occurred)
-        # If was_null=False, the WHERE clause prevented the update
-        return was_null
-
     async def increment_num_clients(self, meeting_id: str) -> None:
         """Atomically increment participant count."""
         query = (
@@ -488,6 +351,27 @@ class MeetingConsentController:
         result = await get_database().fetch_one(query)
         return result is not None
 
+    async def set_cloud_recording_if_missing(
+        self,
+        meeting_id: NonEmptyString,
+        s3_key: NonEmptyString,
+        duration: int,
+    ) -> bool:
+        """Returns True if updated, False if already set."""
+        query = (
+            meetings.update()
+            .where(
+                meetings.c.id == meeting_id,
+                meetings.c.daily_composed_video_s3_key.is_(None),
+            )
+            .values(
+                daily_composed_video_s3_key=s3_key,
+                daily_composed_video_duration=duration,
+            )
+        )
+        result = await get_database().execute(query)
+        return result.rowcount > 0
+
 
 meetings_controller = MeetingController()
 meeting_consent_controller = MeetingConsentController()

server/reflector/db/recordings.py

@@ -4,10 +4,10 @@ from typing import Literal
 import sqlalchemy as sa
 from pydantic import BaseModel, Field
 from sqlalchemy import or_
+from sqlalchemy.dialects.postgresql import insert
 
 from reflector.db import get_database, metadata
 from reflector.utils import generate_uuid4
-from reflector.utils.string import NonEmptyString
 
 recordings = sa.Table(
     "recording",
@@ -31,14 +31,13 @@ recordings = sa.Table(
 class Recording(BaseModel):
     id: str = Field(default_factory=generate_uuid4)
     bucket_name: str
-    # for single-track
     object_key: str
     recorded_at: datetime
-    status: Literal["pending", "processing", "completed", "failed"] = "pending"
+    status: Literal["pending", "processing", "completed", "failed", "orphan"] = (
+        "pending"
+    )
     meeting_id: str | None = None
-    # for multitrack reprocessing
-    # track_keys can be empty list [] if recording finished but no audio was captured (silence/muted)
-    # None means not a multitrack recording, [] means multitrack with no tracks
+    # None = single-track, [] = multitrack with no audio, [keys...] = multitrack with audio
     track_keys: list[str] | None = None
 
     @property
@@ -72,20 +71,6 @@ class RecordingController:
         query = recordings.delete().where(recordings.c.id == id)
         await get_database().execute(query)
 
-    async def set_meeting_id(
-        self,
-        recording_id: NonEmptyString,
-        meeting_id: NonEmptyString,
-    ) -> None:
-        """Link recording to meeting."""
-        query = (
-            recordings.update()
-            .where(recordings.c.id == recording_id)
-            .values(meeting_id=meeting_id)
-        )
-        await get_database().execute(query)
-
-    # no check for existence
     async def get_by_ids(self, recording_ids: list[str]) -> list[Recording]:
         if not recording_ids:
             return []
@@ -104,9 +89,12 @@ class RecordingController:
 
         This is more efficient than fetching all recordings and filtering in Python.
         """
-        from reflector.db.transcripts import (
-            transcripts,  # noqa: PLC0415 cyclic import
-        )
+        # INLINE IMPORT REQUIRED: Circular dependency
+        # - recordings.py needs transcripts table for JOIN query
+        # - transcripts.py imports recordings_controller
+        # - db/__init__.py loads recordings before transcripts (line 31 vs 33)
+        # - Top-level import would fail during module initialization
+        from reflector.db.transcripts import transcripts
 
         query = (
             recordings.select()
@@ -124,5 +112,27 @@ class RecordingController:
         recordings_list = [Recording(**row) for row in results]
         return [r for r in recordings_list if r.is_multitrack]
 
+    async def try_create_with_meeting(self, recording: Recording) -> bool:
+        """Returns True if created, False if already exists."""
+        assert recording.meeting_id is not None, "meeting_id required for non-orphan"
+        assert recording.status != "orphan", "use create_orphan for orphans"
+
+        stmt = insert(recordings).values(**recording.model_dump())
+        stmt = stmt.on_conflict_do_nothing(index_elements=["id"])
+        result = await get_database().execute(stmt)
+
+        return result.rowcount > 0
+
+    async def create_orphan(self, recording: Recording) -> bool:
+        """Returns True if created, False if already exists."""
+        assert recording.status == "orphan", "status must be 'orphan'"
+        assert recording.meeting_id is None, "meeting_id must be NULL for orphan"
+
+        stmt = insert(recordings).values(**recording.model_dump())
+        stmt = stmt.on_conflict_do_nothing(index_elements=["id"])
+        result = await get_database().execute(stmt)
+
+        return result.rowcount > 0
+
 
 recordings_controller = RecordingController()

server/reflector/views/daily.py

@@ -1,4 +1,6 @@
 import json
+import os
+from datetime import datetime, timezone
 from typing import assert_never
 
 from fastapi import APIRouter, HTTPException, Request
@@ -12,7 +14,10 @@ from reflector.dailyco_api import (
     RecordingReadyEvent,
     RecordingStartedEvent,
 )
+from reflector.dailyco_api.recording_orphans import create_and_log_orphan
+from reflector.db.daily_recording_requests import daily_recording_requests_controller
 from reflector.db.meetings import meetings_controller
+from reflector.db.recordings import Recording, recordings_controller
 from reflector.logger import logger as _logger
 from reflector.settings import settings
 from reflector.video_platforms.factory import create_platform_client
@@ -212,10 +217,73 @@ async def _handle_recording_ready(event: RecordingReadyEvent):
 
         track_keys = [t.s3Key for t in tracks if t.type == "audio"]
 
+        # Lookup request
+        match = await daily_recording_requests_controller.find_by_recording_id(
+            recording_id
+        )
+
+        if not match:
+            await create_and_log_orphan(
+                recording_id=recording_id,
+                bucket_name=bucket_name,
+                room_name=room_name,
+                start_ts=event.payload.start_ts,
+                track_keys=track_keys,
+                source="webhook",
+            )
+            return
+
+        meeting_id, _ = match
+
+        # Verify meeting exists
+        meeting = await meetings_controller.get_by_id(meeting_id)
+        if not meeting:
+            logger.error(
+                "Meeting not found (webhook)",
+                recording_id=recording_id,
+                meeting_id=meeting_id,
+            )
+            await create_and_log_orphan(
+                recording_id=recording_id,
+                bucket_name=bucket_name,
+                room_name=room_name,
+                start_ts=event.payload.start_ts,
+                track_keys=track_keys,
+                source="webhook",
+            )
+            return
+
+        # Create recording atomically
+        created = await recordings_controller.try_create_with_meeting(
+            Recording(
+                id=recording_id,
+                bucket_name=bucket_name,
+                object_key=(
+                    os.path.dirname(track_keys[0]) if track_keys else room_name
+                ),
+                recorded_at=datetime.fromtimestamp(
+                    event.payload.start_ts, tz=timezone.utc
+                ),
+                track_keys=track_keys,
+                meeting_id=meeting_id,
+                status="pending",
+            )
+        )
+
+        if not created:
+            # Already created (polling got it first)
+            logger.debug(
+                "Recording already exists (webhook late)",
+                recording_id=recording_id,
+                meeting_id=meeting_id,
+            )
+            return
+
         logger.info(
-            "Raw-tracks recording queuing processing",
+            "Raw-tracks recording queuing processing (webhook)",
             recording_id=recording_id,
             room_name=room_name,
+            meeting_id=meeting_id,
             num_tracks=len(track_keys),
         )
 

server/reflector/views/meetings.py

@@ -1,4 +1,5 @@
 import json
+import logging
 from datetime import datetime, timezone
 from typing import Annotated, Any, Optional
 from uuid import UUID
@@ -9,16 +10,21 @@ from pydantic import BaseModel
 import reflector.auth as auth
 from reflector.dailyco_api import RecordingType
 from reflector.dailyco_api.client import DailyApiError
+from reflector.db.daily_recording_requests import (
+    DailyRecordingRequest,
+    daily_recording_requests_controller,
+)
 from reflector.db.meetings import (
     MeetingConsent,
     meeting_consent_controller,
     meetings_controller,
 )
 from reflector.db.rooms import rooms_controller
-from reflector.logger import logger
 from reflector.utils.string import NonEmptyString
 from reflector.video_platforms.factory import create_platform_client
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter()
 
 
@@ -102,13 +108,6 @@ async def start_recording(
     if not meeting:
         raise HTTPException(status_code=404, detail="Meeting not found")
 
-    log = logger.bind(
-        meeting_id=meeting_id,
-        room_name=meeting.room_name,
-        recording_type=body.type,
-        instance_id=body.instanceId,
-    )
-
     try:
         client = create_platform_client("daily")
         result = await client.start_recording(
@@ -117,9 +116,30 @@ async def start_recording(
             instance_id=body.instanceId,
         )
 
-        log.info(f"Started {body.type} recording via REST API")
+        recording_id = result["id"]
 
-        return {"status": "ok", "result": result}
+        await daily_recording_requests_controller.create(
+            DailyRecordingRequest(
+                recording_id=recording_id,
+                meeting_id=meeting_id,
+                instance_id=body.instanceId,
+                type=body.type,
+                requested_at=datetime.now(timezone.utc),
+            )
+        )
+
+        logger.info(
+            f"Started {body.type} recording via REST API",
+            extra={
+                "meeting_id": meeting_id,
+                "room_name": meeting.room_name,
+                "recording_type": body.type,
+                "instance_id": body.instanceId,
+                "recording_id": recording_id,
+            },
+        )
+
+        return {"status": "ok", "recording_id": recording_id}
 
     except DailyApiError as e:
         # Parse Daily.co error response to detect "has an active stream"
@@ -130,22 +150,42 @@ async def start_recording(
             # "has an active stream" means recording already started by another participant
             # This is SUCCESS from business logic perspective - return 200
             if "has an active stream" in error_info:
-                log.info(
-                    f"{body.type} recording already active (started by another participant)"
+                logger.info(
+                    f"{body.type} recording already active (started by another participant)",
+                    extra={
+                        "meeting_id": meeting_id,
+                        "room_name": meeting.room_name,
+                        "recording_type": body.type,
+                        "instance_id": body.instanceId,
+                    },
                 )
                 return {"status": "already_active", "instanceId": str(body.instanceId)}
         except (json.JSONDecodeError, KeyError):
             pass  # Fall through to error handling
 
         # All other Daily.co API errors
-        log.error(f"Failed to start {body.type} recording", error=str(e))
+        logger.error(
+            f"Failed to start {body.type} recording",
+            extra={
+                "meeting_id": meeting_id,
+                "recording_type": body.type,
+                "error": str(e),
+            },
+        )
         raise HTTPException(
             status_code=500, detail=f"Failed to start recording: {str(e)}"
         )
 
     except Exception as e:
         # Non-Daily.co errors
-        log.error(f"Failed to start {body.type} recording", error=str(e))
+        logger.error(
+            f"Failed to start {body.type} recording",
+            extra={
+                "meeting_id": meeting_id,
+                "recording_type": body.type,
+                "error": str(e),
+            },
+        )
         raise HTTPException(
             status_code=500, detail=f"Failed to start recording: {str(e)}"
         )

server/reflector/worker/ics_sync.py

@@ -5,7 +5,7 @@ from celery import shared_task
 from celery.utils.log import get_task_logger
 
 from reflector.asynctask import asynctask
-from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
+from reflector.db.calendar_events import calendar_events_controller
 from reflector.db.meetings import meetings_controller
 from reflector.db.rooms import Room, rooms_controller
 from reflector.redis_cache import RedisAsyncLock
@@ -83,9 +83,10 @@ def _should_sync(room) -> bool:
     return time_since_sync.total_seconds() >= room.ics_fetch_interval
 
 
-async def create_upcoming_meetings_for_event(
-    event: CalendarEvent, create_window: datetime, room: Room
-):
+MEETING_DEFAULT_DURATION = timedelta(hours=1)
+
+
+async def create_upcoming_meetings_for_event(event, create_window, room: Room):
     if event.start_time <= create_window:
         return
     existing_meeting = await meetings_controller.get_by_calendar_event(event.id, room)
@@ -93,21 +94,6 @@ async def create_upcoming_meetings_for_event(
     if existing_meeting:
         return
 
-    # Prevent duplicate meetings from aggregated calendar feeds
-    # (e.g. same event appears with different UIDs from Cal.com and Google Calendar)
-    end_date = event.end_time
-    existing_by_time = await meetings_controller.get_by_room_and_time_window(
-        room, event.start_time, end_date
-    )
-    if existing_by_time:
-        logger.info(
-            "Skipping duplicate calendar event - meeting already exists for this time window",
-            room_id=room.id,
-            event_id=event.id,
-            existing_meeting_id=existing_by_time.id,
-        )
-        return
-
     logger.info(
         "Pre-creating meeting for calendar event",
         room_id=room.id,
@@ -116,6 +102,8 @@ async def create_upcoming_meetings_for_event(
     )
 
     try:
+        end_date = event.end_time or (event.start_time + MEETING_DEFAULT_DURATION)
+
         client = create_platform_client(room.platform)
 
         meeting_data = await client.create_meeting(

server/reflector/worker/process.py

@@ -1,6 +1,5 @@
 import json
 import os
-import re
 from datetime import datetime, timezone
 from typing import List, Literal
 from urllib.parse import unquote
@@ -13,10 +12,12 @@ from celery.utils.log import get_task_logger
 from pydantic import ValidationError
 
 from reflector.dailyco_api import FinishedRecordingResponse, RecordingResponse
+from reflector.dailyco_api.recording_orphans import create_and_log_orphan
 from reflector.db.daily_participant_sessions import (
     DailyParticipantSession,
     daily_participant_sessions_controller,
 )
+from reflector.db.daily_recording_requests import daily_recording_requests_controller
 from reflector.db.meetings import meetings_controller
 from reflector.db.recordings import Recording, recordings_controller
 from reflector.db.rooms import rooms_controller
@@ -230,79 +231,44 @@ async def _process_multitrack_recording_inner(
     recording_start_ts: int,
 ):
     """
-    Process multitrack recording (first time or reprocessing).
+    Process multitrack recording.
 
-    For first processing (webhook/polling):
-    - Uses recording_start_ts for time-based meeting matching (no instanceId available)
-
-    For reprocessing:
-    - Uses recording.meeting_id directly (already linked during first processing)
-    - recording_start_ts is ignored
+    Recording must already exist with meeting_id set (created by webhook/polling before queueing).
     """
 
-    tz = timezone.utc
-    recorded_at = datetime.now(tz)
-    try:
-        if track_keys:
-            folder = os.path.basename(os.path.dirname(track_keys[0]))
-            ts_match = re.search(r"(\d{14})$", folder)
-            if ts_match:
-                ts = ts_match.group(1)
-                recorded_at = datetime.strptime(ts, "%Y%m%d%H%M%S").replace(tzinfo=tz)
-    except Exception as e:
-        logger.warning(
-            f"Could not parse recorded_at from keys, using now() {recorded_at}",
-            e,
-            exc_info=True,
-        )
-
-    # Check if recording already exists (reprocessing path)
+    # Get recording (must exist - created by webhook/polling)
     recording = await recordings_controller.get_by_id(recording_id)
 
-    if recording and recording.meeting_id:
-        # Reprocessing: recording exists with meeting already linked
-        meeting = await meetings_controller.get_by_id(recording.meeting_id)
-        if not meeting:
-            logger.error(
-                "Reprocessing: meeting not found for recording - skipping",
-                meeting_id=recording.meeting_id,
-                recording_id=recording_id,
-            )
-            return
+    if not recording:
+        logger.error(
+            "Recording not found - should have been created by webhook/polling",
+            recording_id=recording_id,
+        )
+        return
 
-        logger.info(
-            "Reprocessing: using existing recording.meeting_id",
+    if not recording.meeting_id:
+        logger.error(
+            "Recording has no meeting_id - orphan should not be queued",
             recording_id=recording_id,
-            meeting_id=meeting.id,
-            room_name=daily_room_name,
         )
-    else:
-        # First processing: recording doesn't exist, need time-based matching
-        # (Daily.co doesn't return instanceId in API, must match by timestamp)
-        recording_start = datetime.fromtimestamp(recording_start_ts, tz=timezone.utc)
-        meeting = await meetings_controller.get_by_room_name_and_time(
-            room_name=daily_room_name,
-            recording_start=recording_start,
-            time_window_hours=168,  # 1 week
-        )
-        if not meeting:
-            logger.error(
-                "Raw-tracks: no meeting found within 1-week window (time-based match) - skipping",
-                recording_id=recording_id,
-                room_name=daily_room_name,
-                recording_start_ts=recording_start_ts,
-                recording_start=recording_start.isoformat(),
-            )
-            return  # Skip processing, will retry on next poll
-        logger.info(
-            "First processing: found meeting via time-based matching",
-            meeting_id=meeting.id,
-            room_name=daily_room_name,
+        return
+
+    # Get meeting
+    meeting = await meetings_controller.get_by_id(recording.meeting_id)
+    if not meeting:
+        logger.error(
+            "Meeting not found for recording",
+            meeting_id=recording.meeting_id,
             recording_id=recording_id,
-            time_delta_seconds=abs(
-                (meeting.start_date - recording_start).total_seconds()
-            ),
         )
+        return
+
+    logger.info(
+        "Processing multitrack recording",
+        recording_id=recording_id,
+        meeting_id=meeting.id,
+        room_name=daily_room_name,
+    )
 
     room_name_base = extract_base_room_name(daily_room_name)
 
@@ -310,33 +276,6 @@ async def _process_multitrack_recording_inner(
     if not room:
         raise Exception(f"Room not found: {room_name_base}")
 
-    if not recording:
-        # Create recording (only happens during first processing)
-        object_key_dir = os.path.dirname(track_keys[0]) if track_keys else ""
-        recording = await recordings_controller.create(
-            Recording(
-                id=recording_id,
-                bucket_name=bucket_name,
-                object_key=object_key_dir,
-                recorded_at=recorded_at,
-                meeting_id=meeting.id,
-                track_keys=track_keys,
-            )
-        )
-    elif not recording.meeting_id:
-        # Recording exists but meeting_id is null (failed first processing)
-        # Update with meeting from time-based matching
-        await recordings_controller.set_meeting_id(
-            recording_id=recording.id,
-            meeting_id=meeting.id,
-        )
-        recording.meeting_id = meeting.id
-        logger.info(
-            "Updated existing recording with meeting_id",
-            recording_id=recording.id,
-            meeting_id=meeting.id,
-        )
-
     transcript = await transcripts_controller.get_by_recording_id(recording.id)
     if not transcript:
         transcript = await transcripts_controller.add(
@@ -522,7 +461,7 @@ async def store_cloud_recording(
     Store cloud recording reference in meeting table.
 
     Common function for both webhook and polling code paths.
-    Uses time-based matching to handle duplicate room_name values.
+    Uses direct recording_id lookup via daily_recording_requests table.
 
     Args:
         recording_id: Daily.co recording ID
@@ -535,155 +474,170 @@ async def store_cloud_recording(
     Returns:
         True if stored, False if skipped/failed
     """
-    recording_start = datetime.fromtimestamp(start_ts, tz=timezone.utc)
+    # Lookup request
+    match = await daily_recording_requests_controller.find_by_recording_id(recording_id)
 
-    meeting = await meetings_controller.get_by_room_name_and_time(
-        room_name=room_name,
-        recording_start=recording_start,
-        time_window_hours=168,  # 1 week
-    )
-
-    if not meeting:
-        logger.warning(
-            f"Cloud recording ({source}): no meeting found within 1-week window",
+    if not match:
+        # ORPHAN: No request found (pre-migration recording or failed request creation)
+        await create_and_log_orphan(
             recording_id=recording_id,
+            bucket_name="",
             room_name=room_name,
-            recording_start_ts=start_ts,
-            recording_start=recording_start.isoformat(),
+            start_ts=start_ts,
+            track_keys=None,
+            source=source,
         )
         return False
 
+    meeting_id, _ = match
+
     success = await meetings_controller.set_cloud_recording_if_missing(
-        meeting_id=meeting.id,
+        meeting_id=meeting_id,
         s3_key=s3_key,
         duration=duration,
     )
 
     if not success:
         logger.debug(
-            f"Cloud recording ({source}): already set (race lost)",
+            f"Cloud recording ({source}): already set (stop/restart?)",
             recording_id=recording_id,
             room_name=room_name,
-            meeting_id=meeting.id,
+            meeting_id=meeting_id,
         )
         return False
 
     logger.info(
-        f"Cloud recording stored via {source} (time-based match)",
-        meeting_id=meeting.id,
+        f"Cloud recording stored via {source}",
+        meeting_id=meeting_id,
         recording_id=recording_id,
         s3_key=s3_key,
         duration=duration,
-        time_delta_seconds=abs((meeting.start_date - recording_start).total_seconds()),
     )
     return True
 
 
 async def _poll_cloud_recordings(cloud_recordings: List[FinishedRecordingResponse]):
-    """
-    Store cloud recordings missing from meeting table via polling.
+    """Process cloud recordings (database deduplication, worker-agnostic).
 
-    Uses time-based matching via store_cloud_recording().
+    Cloud recordings stored in meeting.daily_composed_video_s3_key, not recording table.
+    Only first cloud recording per meeting is kept (existing behavior).
     """
     if not cloud_recordings:
         return
 
-    stored_count = 0
-    for recording in cloud_recordings:
-        # Extract S3 key from recording (cloud recordings use s3key field)
-        s3_key = recording.s3key or (recording.s3.key if recording.s3 else None)
-        if not s3_key:
-            logger.warning(
-                "Cloud recording: missing S3 key",
-                recording_id=recording.id,
-                room_name=recording.room_name,
+    for rec in cloud_recordings:
+        # Lookup request
+        match = await daily_recording_requests_controller.find_by_recording_id(rec.id)
+
+        if not match:
+            await create_and_log_orphan(
+                recording_id=rec.id,
+                bucket_name="",
+                room_name=rec.room_name,
+                start_ts=rec.start_ts,
+                track_keys=None,
+                source="polling",
             )
             continue
 
-        stored = await store_cloud_recording(
-            recording_id=recording.id,
-            room_name=recording.room_name,
-            s3_key=s3_key,
-            duration=recording.duration,
-            start_ts=recording.start_ts,
-            source="polling",
-        )
-        if stored:
-            stored_count += 1
+        meeting_id, _ = match
 
-    logger.info(
-        "Cloud recording polling complete",
-        total=len(cloud_recordings),
-        stored=stored_count,
-    )
+        if not rec.s3key:
+            logger.error("Cloud recording missing s3_key", recording_id=rec.id)
+            continue
+
+        # Store in meeting table (atomic, only if not already set)
+        success = await meetings_controller.set_cloud_recording_if_missing(
+            meeting_id=meeting_id,
+            s3_key=rec.s3key,
+            duration=rec.duration,
+        )
+
+        if success:
+            logger.info(
+                "Stored cloud recording", recording_id=rec.id, meeting_id=meeting_id
+            )
+        else:
+            logger.warning(
+                "Cloud recording already exists for meeting (stop/restart?)",
+                recording_id=rec.id,
+                meeting_id=meeting_id,
+            )
 
 
 async def _poll_raw_tracks_recordings(
     raw_tracks_recordings: List[FinishedRecordingResponse],
-    bucket_name: str,
-):
-    """Queue raw-tracks recordings missing from DB (existing logic)."""
+    bucket_name: NonEmptyString,
+) -> None:
+    """Process raw-tracks (database deduplication, worker-agnostic)."""
     if not raw_tracks_recordings:
         return
 
-    recording_ids = [rec.id for rec in raw_tracks_recordings]
-    existing_recordings = await recordings_controller.get_by_ids(recording_ids)
-    existing_ids = {rec.id for rec in existing_recordings}
+    for rec in raw_tracks_recordings:
+        # Lookup request FIRST (before any DB writes)
+        match = await daily_recording_requests_controller.find_by_recording_id(rec.id)
 
-    missing_recordings = [
-        rec for rec in raw_tracks_recordings if rec.id not in existing_ids
-    ]
-
-    if not missing_recordings:
-        logger.debug(
-            "All raw-tracks recordings already in DB",
-            api_count=len(raw_tracks_recordings),
-            existing_count=len(existing_recordings),
-        )
-        return
-
-    logger.info(
-        "Found raw-tracks recordings missing from DB",
-        missing_count=len(missing_recordings),
-        total_api_count=len(raw_tracks_recordings),
-        existing_count=len(existing_recordings),
-    )
-
-    for recording in missing_recordings:
-        if not recording.tracks:
-            logger.warning(
-                "Finished raw-tracks recording has no tracks (no audio captured)",
-                recording_id=recording.id,
-                room_name=recording.room_name,
+        if not match:
+            await create_and_log_orphan(
+                recording_id=rec.id,
+                bucket_name=bucket_name,
+                room_name=rec.room_name,
+                start_ts=rec.start_ts,
+                track_keys=[t.s3Key for t in rec.tracks if t.type == "audio"],
+                source="polling",
             )
             continue
 
-        track_keys = [t.s3Key for t in recording.tracks if t.type == "audio"]
+        meeting_id, _ = match
 
-        if not track_keys:
-            logger.warning(
-                "No audio tracks found in raw-tracks recording",
-                recording_id=recording.id,
-                room_name=recording.room_name,
-                total_tracks=len(recording.tracks),
+        # Verify meeting exists
+        meeting = await meetings_controller.get_by_id(meeting_id)
+        if not meeting:
+            logger.error(
+                "Meeting not found", recording_id=rec.id, meeting_id=meeting_id
+            )
+            await create_and_log_orphan(
+                recording_id=rec.id,
+                bucket_name=bucket_name,
+                room_name=rec.room_name,
+                start_ts=rec.start_ts,
+                track_keys=[t.s3Key for t in rec.tracks if t.type == "audio"],
+                source="polling",
             )
             continue
 
-        logger.info(
-            "Queueing missing raw-tracks recording for processing",
-            recording_id=recording.id,
-            room_name=recording.room_name,
-            track_count=len(track_keys),
+        # DEDUPLICATION: Atomically create recording (single operation, no race window)
+        # ON CONFLICT → concurrent poller already got it, skip entire logic
+        track_keys = [t.s3Key for t in rec.tracks if t.type == "audio"]
+
+        created = await recordings_controller.try_create_with_meeting(
+            Recording(
+                id=rec.id,
+                bucket_name=bucket_name,
+                object_key=os.path.dirname(track_keys[0]) if track_keys else "",
+                recorded_at=datetime.fromtimestamp(rec.start_ts, tz=timezone.utc),
+                track_keys=track_keys,
+                meeting_id=meeting_id,  # Set at creation (constraint-safe)
+                status="pending",
+            )
         )
 
+        if not created:
+            # Conflict: another poller already created/queued this
+            # Skip all remaining logic (match already done by winner)
+            continue
+
+        # Only winner reaches here - queue processing (works with Celery or Hatchet)
         process_multitrack_recording.delay(
+            recording_id=rec.id,
+            daily_room_name=rec.room_name,
+            recording_start_ts=rec.start_ts,
             bucket_name=bucket_name,
-            daily_room_name=recording.room_name,
-            recording_id=recording.id,
             track_keys=track_keys,
-            recording_start_ts=recording.start_ts,
         )
 
+        logger.info("Queued recording", recording_id=rec.id, meeting_id=meeting_id)
+
 
 async def poll_daily_room_presence(meeting_id: str) -> None:
     """Poll Daily.co room presence and reconcile with DB sessions. New presence is added, old presence is marked as closed.

server/reflector/ws_manager.py

@@ -11,6 +11,7 @@ broadcast messages to all connected websockets.
 
 import asyncio
 import json
+import threading
 
 import redis.asyncio as redis
 from fastapi import WebSocket
@@ -97,7 +98,6 @@ class WebsocketManager:
 
     async def _pubsub_data_reader(self, pubsub_subscriber):
         while True:
-            # timeout=1.0 prevents tight CPU loop when no messages available
             message = await pubsub_subscriber.get_message(
                 ignore_subscribe_messages=True
             )
@@ -109,38 +109,29 @@ class WebsocketManager:
                     await socket.send_json(data)
 
 
-# Process-global singleton to ensure only one WebsocketManager instance exists.
-# Multiple instances would cause resource leaks and CPU issues.
-_ws_manager: WebsocketManager | None = None
-
-
 def get_ws_manager() -> WebsocketManager:
     """
-    Returns the global WebsocketManager singleton.
+    Returns the WebsocketManager instance for managing websockets.
 
-    Creates instance on first call, subsequent calls return cached instance.
-    Thread-safe via GIL. Concurrent initialization may create duplicate
-    instances but last write wins (acceptable for this use case).
+    This function initializes and returns the WebsocketManager instance,
+    which is responsible for managing websockets and handling websocket
+    connections.
 
     Returns:
-        WebsocketManager: The global WebsocketManager instance.
+        WebsocketManager: The initialized WebsocketManager instance.
+
+    Raises:
+        ImportError: If the 'reflector.settings' module cannot be imported.
+        RedisConnectionError: If there is an error connecting to the Redis server.
     """
-    global _ws_manager
+    local = threading.local()
+    if hasattr(local, "ws_manager"):
+        return local.ws_manager
 
-    if _ws_manager is not None:
-        return _ws_manager
-
-    # No lock needed - GIL makes this safe enough
-    # Worst case: race creates two instances, last assignment wins
     pubsub_client = RedisPubSubManager(
         host=settings.REDIS_HOST,
         port=settings.REDIS_PORT,
     )
-    _ws_manager = WebsocketManager(pubsub_client=pubsub_client)
-    return _ws_manager
-
-
-def reset_ws_manager() -> None:
-    """Reset singleton for testing. DO NOT use in production."""
-    global _ws_manager
-    _ws_manager = None
+    ws_manager = WebsocketManager(pubsub_client=pubsub_client)
+    local.ws_manager = ws_manager
+    return ws_manager

server/test_daily_api_recordings.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""Test script to fetch Daily.co recordings for a specific room and show raw API response."""
+
+import asyncio
+import json
+
+from reflector.video_platforms.factory import create_platform_client
+
+
+async def main():
+    room_name = "daily-private-igor-20260110042117"
+
+    print(f"\n=== Fetching recordings for room: {room_name} ===\n")
+
+    async with create_platform_client("daily") as client:
+        recordings = await client.list_recordings(room_name=room_name)
+
+    print(f"Found {len(recordings)} recording objects from Daily.co API\n")
+
+    for i, rec in enumerate(recordings, 1):
+        print(f"--- Recording #{i} ---")
+        print(f"ID: {rec.id}")
+        print(f"Room: {rec.room_name}")
+        print(f"Start TS: {rec.start_ts}")
+        print(f"Status: {rec.status}")
+        print(f"Duration: {rec.duration}")
+        print(f"Type: {rec.type}")
+        print(f"Tracks count: {len(rec.tracks)}")
+
+        if rec.tracks:
+            print(f"Tracks:")
+            for j, track in enumerate(rec.tracks, 1):
+                print(f"  Track {j}: {track.s3Key}")
+
+        print(f"\nRaw JSON:\n{json.dumps(rec.model_dump(), indent=2, default=str)}\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

server/tests/conftest.py

@@ -1,5 +1,6 @@
 import os
 from contextlib import asynccontextmanager
+from tempfile import NamedTemporaryFile
 from unittest.mock import patch
 
 import pytest
@@ -332,14 +333,11 @@ def celery_enable_logging():
 
 @pytest.fixture(scope="session")
 def celery_config():
-    redis_host = os.environ.get("REDIS_HOST", "localhost")
-    redis_port = os.environ.get("REDIS_PORT", "6379")
-    # Use db 2 to avoid conflicts with main app
-    redis_url = f"redis://{redis_host}:{redis_port}/2"
-    yield {
-        "broker_url": redis_url,
-        "result_backend": redis_url,
-    }
+    with NamedTemporaryFile() as f:
+        yield {
+            "broker_url": "memory://",
+            "result_backend": f"db+sqlite:///{f.name}",
+        }
 
 
 @pytest.fixture(scope="session")
@@ -372,12 +370,9 @@ async def ws_manager_in_memory(monkeypatch):
         def __init__(self, queue: asyncio.Queue):
             self.queue = queue
 
-        async def get_message(
-            self, ignore_subscribe_messages: bool = True, timeout: float | None = None
-        ):
-            wait_timeout = timeout if timeout is not None else 0.05
+        async def get_message(self, ignore_subscribe_messages: bool = True):
             try:
-                return await asyncio.wait_for(self.queue.get(), timeout=wait_timeout)
+                return await asyncio.wait_for(self.queue.get(), timeout=0.05)
             except Exception:
                 return None
 

server/tests/test_daily_recording_requests.py

@@ -0,0 +1,258 @@
+from datetime import datetime, timezone
+from uuid import UUID
+
+import pytest
+
+from reflector.db.daily_recording_requests import (
+    DailyRecordingRequest,
+    daily_recording_requests_controller,
+)
+from reflector.db.meetings import Meeting, meetings_controller
+from reflector.db.recordings import Recording, recordings_controller
+from reflector.db.rooms import Room, rooms_controller
+
+
+@pytest.mark.asyncio
+async def test_create_request():
+    """Test creating a recording request."""
+    # Create meeting first
+    room = Room(id="test-room", name="Test Room", slug="test-room", user_id="test-user")
+    await rooms_controller.create(room)
+
+    meeting = Meeting(
+        id="meeting-123",
+        room_name="test-room",
+        start_date=datetime.now(timezone.utc),
+        end_date=None,
+        recording_type="cloud",
+    )
+    await meetings_controller.create(meeting)
+
+    request = DailyRecordingRequest(
+        recording_id="rec-1",
+        meeting_id="meeting-123",
+        instance_id=UUID("a1b2c3d4-e5f6-7890-abcd-ef1234567890"),
+        type="cloud",
+        requested_at=datetime.now(timezone.utc),
+    )
+
+    await daily_recording_requests_controller.create(request)
+
+    result = await daily_recording_requests_controller.find_by_recording_id("rec-1")
+    assert result is not None
+    assert result[0] == "meeting-123"
+    assert result[1] == "cloud"
+
+
+@pytest.mark.asyncio
+async def test_multiple_recordings_same_meeting():
+    """Test stop/restart creates multiple request rows."""
+    # Create room and meeting
+    room = Room(
+        id="test-room-2", name="Test Room 2", slug="test-room-2", user_id="test-user"
+    )
+    await rooms_controller.create(room)
+
+    meeting_id = "meeting-456"
+    meeting = Meeting(
+        id=meeting_id,
+        room_name="test-room-2",
+        start_date=datetime.now(timezone.utc),
+        end_date=None,
+        recording_type="cloud",
+    )
+    await meetings_controller.create(meeting)
+
+    instance_id = UUID("b1c2d3e4-f5a6-7890-abcd-ef1234567890")
+
+    # First recording
+    await daily_recording_requests_controller.create(
+        DailyRecordingRequest(
+            recording_id="rec-1",
+            meeting_id=meeting_id,
+            instance_id=instance_id,
+            type="cloud",
+            requested_at=datetime.now(timezone.utc),
+        )
+    )
+
+    # Stop, then restart (new recording_id, same instance_id)
+    await daily_recording_requests_controller.create(
+        DailyRecordingRequest(
+            recording_id="rec-2",  # DIFFERENT
+            meeting_id=meeting_id,
+            instance_id=instance_id,  # SAME
+            type="cloud",
+            requested_at=datetime.now(timezone.utc),
+        )
+    )
+
+    # Both exist
+    requests = await daily_recording_requests_controller.get_by_meeting_id(meeting_id)
+    assert len(requests) == 2
+    assert {r.recording_id for r in requests} == {"rec-1", "rec-2"}
+
+
+@pytest.mark.asyncio
+async def test_deduplication_via_database():
+    """Test concurrent pollers use database for deduplication."""
+    # Create room and meeting
+    room = Room(
+        id="test-room-3", name="Test Room 3", slug="test-room-3", user_id="test-user"
+    )
+    await rooms_controller.create(room)
+
+    meeting = Meeting(
+        id="meeting-789",
+        room_name="test-room-3",
+        start_date=datetime.now(timezone.utc),
+        end_date=None,
+        recording_type="raw-tracks",
+    )
+    await meetings_controller.create(meeting)
+
+    recording_id = "rec-123"
+
+    # Poller 1
+    created1 = await recordings_controller.try_create_with_meeting(
+        Recording(
+            id=recording_id,
+            bucket_name="test-bucket",
+            object_key="test-key",
+            recorded_at=datetime.now(timezone.utc),
+            meeting_id="meeting-789",
+            status="pending",
+            track_keys=["track1.webm", "track2.webm"],
+        )
+    )
+    assert created1 is True  # First wins
+
+    # Poller 2 (concurrent)
+    created2 = await recordings_controller.try_create_with_meeting(
+        Recording(
+            id=recording_id,
+            bucket_name="test-bucket",
+            object_key="test-key",
+            recorded_at=datetime.now(timezone.utc),
+            meeting_id="meeting-789",
+            status="pending",
+            track_keys=["track1.webm", "track2.webm"],
+        )
+    )
+    assert created2 is False  # Conflict, skip
+
+
+@pytest.mark.asyncio
+async def test_orphan_logged_once():
+    """Test orphan marked once, skipped on re-poll."""
+    # First poll
+    created1 = await recordings_controller.create_orphan(
+        Recording(
+            id="orphan-123",
+            bucket_name="test-bucket",
+            object_key="orphan-key",
+            recorded_at=datetime.now(timezone.utc),
+            meeting_id=None,
+            status="orphan",
+            track_keys=None,
+        )
+    )
+    assert created1 is True
+
+    # Second poll (same orphan discovered again)
+    created2 = await recordings_controller.create_orphan(
+        Recording(
+            id="orphan-123",
+            bucket_name="test-bucket",
+            object_key="orphan-key",
+            recorded_at=datetime.now(timezone.utc),
+            meeting_id=None,
+            status="orphan",
+            track_keys=None,
+        )
+    )
+    assert created2 is False  # Already exists
+
+    # Verify it exists
+    existing = await recordings_controller.get_by_id("orphan-123")
+    assert existing is not None
+    assert existing.status == "orphan"
+
+
+@pytest.mark.asyncio
+async def test_orphan_constraints():
+    """Test orphan invariants are enforced."""
+    # Can't create orphan with meeting_id
+    with pytest.raises(AssertionError, match="meeting_id must be NULL"):
+        await recordings_controller.create_orphan(
+            Recording(
+                id="bad-orphan-1",
+                bucket_name="test",
+                object_key="test",
+                recorded_at=datetime.now(timezone.utc),
+                meeting_id="meeting-123",  # Should be None
+                status="orphan",
+                track_keys=None,
+            )
+        )
+
+    # Can't create orphan with wrong status
+    with pytest.raises(AssertionError, match="status must be 'orphan'"):
+        await recordings_controller.create_orphan(
+            Recording(
+                id="bad-orphan-2",
+                bucket_name="test",
+                object_key="test",
+                recorded_at=datetime.now(timezone.utc),
+                meeting_id=None,
+                status="pending",  # Should be "orphan"
+                track_keys=None,
+            )
+        )
+
+
+@pytest.mark.asyncio
+async def test_try_create_with_meeting_constraints():
+    """Test try_create_with_meeting enforces constraints."""
+    # Create room and meeting
+    room = Room(
+        id="test-room-4", name="Test Room 4", slug="test-room-4", user_id="test-user"
+    )
+    await rooms_controller.create(room)
+
+    meeting = Meeting(
+        id="meeting-999",
+        room_name="test-room-4",
+        start_date=datetime.now(timezone.utc),
+        end_date=None,
+        recording_type="cloud",
+    )
+    await meetings_controller.create(meeting)
+
+    # Can't create with orphan status
+    with pytest.raises(AssertionError, match="use create_orphan"):
+        await recordings_controller.try_create_with_meeting(
+            Recording(
+                id="bad-rec-1",
+                bucket_name="test",
+                object_key="test",
+                recorded_at=datetime.now(timezone.utc),
+                meeting_id="meeting-999",
+                status="orphan",  # Should not be orphan
+                track_keys=None,
+            )
+        )
+
+    # Can't create without meeting_id
+    with pytest.raises(AssertionError, match="meeting_id required"):
+        await recordings_controller.try_create_with_meeting(
+            Recording(
+                id="bad-rec-2",
+                bucket_name="test",
+                object_key="test",
+                recorded_at=datetime.now(timezone.utc),
+                meeting_id=None,  # Should have meeting_id
+                status="pending",
+                track_keys=None,
+            )
+        )

server/tests/test_ics_dedup.py

@@ -1,190 +0,0 @@
-from datetime import datetime, timedelta, timezone
-from unittest.mock import AsyncMock, patch
-
-import pytest
-
-from reflector.db import get_database
-from reflector.db.calendar_events import CalendarEvent, calendar_events_controller
-from reflector.db.meetings import meetings
-from reflector.db.rooms import rooms_controller
-from reflector.worker.ics_sync import create_upcoming_meetings_for_event
-
-
-@pytest.mark.asyncio
-async def test_duplicate_calendar_event_does_not_create_duplicate_meeting():
-    """When an aggregated ICS feed contains the same event with different UIDs
-    (e.g. Cal.com UID + Google Calendar UUID), only one meeting should be created."""
-
-    room = await rooms_controller.add(
-        name="dedup-test-room",
-        user_id="test-user",
-        zulip_auto_post=False,
-        zulip_stream="",
-        zulip_topic="",
-        is_locked=False,
-        room_mode="normal",
-        recording_type="cloud",
-        recording_trigger="automatic-2nd-participant",
-        is_shared=False,
-        ics_url="https://calendar.example.com/dedup.ics",
-        ics_enabled=True,
-    )
-
-    now = datetime.now(timezone.utc)
-    start_time = now + timedelta(hours=1)
-    end_time = now + timedelta(hours=2)
-
-    # Create first calendar event (Cal.com UID)
-    event1 = await calendar_events_controller.upsert(
-        CalendarEvent(
-            room_id=room.id,
-            ics_uid="abc123@Cal.com",
-            title="Team Standup",
-            start_time=start_time,
-            end_time=end_time,
-        )
-    )
-
-    # create_window must be before start_time for the function to proceed
-    create_window = now - timedelta(minutes=6)
-
-    # Create meeting for event1
-    with patch(
-        "reflector.worker.ics_sync.create_platform_client"
-    ) as mock_platform_factory:
-        mock_client = AsyncMock()
-
-        async def mock_create_meeting_1(room_name_prefix, *, end_date, room):
-            return AsyncMock(
-                meeting_id="meeting-1",
-                room_name="dedup-test-room-abc",
-                room_url="https://mock.video/dedup-test-room-abc",
-                host_room_url="https://mock.video/dedup-test-room-abc?host=true",
-            )
-
-        mock_client.create_meeting = mock_create_meeting_1
-        mock_client.upload_logo = AsyncMock()
-        mock_platform_factory.return_value = mock_client
-
-        await create_upcoming_meetings_for_event(event1, create_window, room)
-
-    # Verify meeting was created
-    results = await get_database().fetch_all(
-        meetings.select().where(meetings.c.room_id == room.id)
-    )
-    assert len(results) == 1, f"Expected 1 meeting, got {len(results)}"
-
-    # Create second calendar event with different UID but same time window (Google Calendar UUID)
-    event2 = await calendar_events_controller.upsert(
-        CalendarEvent(
-            room_id=room.id,
-            ics_uid="550e8400-e29b-41d4-a716-446655440000",
-            title="Team Standup",
-            start_time=start_time,
-            end_time=end_time,
-        )
-    )
-
-    # Try to create meeting for event2 - should be skipped due to dedup
-    with patch(
-        "reflector.worker.ics_sync.create_platform_client"
-    ) as mock_platform_factory:
-        mock_client = AsyncMock()
-        create_meeting_called = False
-
-        async def mock_create_meeting_2(room_name_prefix, *, end_date, room):
-            nonlocal create_meeting_called
-            create_meeting_called = True
-
-        mock_client.create_meeting = mock_create_meeting_2
-        mock_client.upload_logo = AsyncMock()
-        mock_platform_factory.return_value = mock_client
-
-        await create_upcoming_meetings_for_event(event2, create_window, room)
-
-        # Platform client should NOT have been called for the duplicate
-        assert (
-            not create_meeting_called
-        ), "create_meeting should not be called for duplicate"
-
-    # Verify still only 1 meeting
-    results = await get_database().fetch_all(
-        meetings.select().where(meetings.c.room_id == room.id)
-    )
-    assert len(results) == 1, f"Expected 1 meeting after dedup, got {len(results)}"
-
-
-@pytest.mark.asyncio
-async def test_different_time_windows_create_separate_meetings():
-    """Events at different times should create separate meetings, even if titles match."""
-
-    room = await rooms_controller.add(
-        name="dedup-diff-time-room",
-        user_id="test-user",
-        zulip_auto_post=False,
-        zulip_stream="",
-        zulip_topic="",
-        is_locked=False,
-        room_mode="normal",
-        recording_type="cloud",
-        recording_trigger="automatic-2nd-participant",
-        is_shared=False,
-        ics_url="https://calendar.example.com/dedup2.ics",
-        ics_enabled=True,
-    )
-
-    now = datetime.now(timezone.utc)
-    create_window = now - timedelta(minutes=6)
-
-    # Event 1: 1-2pm
-    event1 = await calendar_events_controller.upsert(
-        CalendarEvent(
-            room_id=room.id,
-            ics_uid="event-morning@Cal.com",
-            title="Team Standup",
-            start_time=now + timedelta(hours=1),
-            end_time=now + timedelta(hours=2),
-        )
-    )
-
-    # Event 2: 3-4pm (different time)
-    event2 = await calendar_events_controller.upsert(
-        CalendarEvent(
-            room_id=room.id,
-            ics_uid="event-afternoon@Cal.com",
-            title="Team Standup",
-            start_time=now + timedelta(hours=3),
-            end_time=now + timedelta(hours=4),
-        )
-    )
-
-    with patch(
-        "reflector.worker.ics_sync.create_platform_client"
-    ) as mock_platform_factory:
-        mock_client = AsyncMock()
-
-        call_count = 0
-
-        async def mock_create_meeting(room_name_prefix, *, end_date, room):
-            nonlocal call_count
-            call_count += 1
-            return AsyncMock(
-                meeting_id=f"meeting-{call_count}",
-                room_name=f"dedup-diff-time-room-{call_count}",
-                room_url=f"https://mock.video/dedup-diff-time-room-{call_count}",
-                host_room_url=f"https://mock.video/dedup-diff-time-room-{call_count}?host=true",
-            )
-
-        mock_client.create_meeting = mock_create_meeting
-        mock_client.upload_logo = AsyncMock()
-        mock_platform_factory.return_value = mock_client
-
-        await create_upcoming_meetings_for_event(event1, create_window, room)
-        await create_upcoming_meetings_for_event(event2, create_window, room)
-
-    results = await get_database().fetch_all(
-        meetings.select().where(meetings.c.room_id == room.id)
-    )
-    assert (
-        len(results) == 2
-    ), f"Expected 2 meetings for different times, got {len(results)}"

server/tests/test_recording_request_flow.py

@@ -0,0 +1,300 @@
+"""
+Integration tests for recording request flow.
+
+These tests verify the end-to-end flow of:
+1. Starting a recording (creates request)
+2. Webhook/polling discovering recording (matches via request)
+3. Recording processing (uses existing meeting_id)
+"""
+
+from datetime import datetime, timezone
+from uuid import UUID, uuid4
+
+import pytest
+
+from reflector.db.daily_recording_requests import (
+    DailyRecordingRequest,
+    daily_recording_requests_controller,
+)
+from reflector.db.meetings import Meeting, meetings_controller
+from reflector.db.recordings import Recording, recordings_controller
+from reflector.db.rooms import Room, rooms_controller
+
+
+@pytest.mark.asyncio
+async def test_recording_request_flow_cloud(client):
+    """Test full cloud recording flow: start -> webhook -> match"""
+    # Create room and meeting
+    room = Room(id="test-room", name="Test Room", slug="test-room", user_id="test-user")
+    await rooms_controller.create(room)
+
+    meeting_id = f"meeting-{uuid4()}"
+    meeting = Meeting(
+        id=meeting_id,
+        room_name="test-room",
+        start_date=datetime.now(timezone.utc),
+        end_date=None,
+        recording_type="cloud",
+    )
+    await meetings_controller.create(meeting)
+
+    # Simulate recording start (what endpoint does)
+    recording_id = "rec-cloud-123"
+    instance_id = UUID("a1b2c3d4-e5f6-7890-abcd-ef1234567890")
+
+    request = DailyRecordingRequest(
+        recording_id=recording_id,
+        meeting_id=meeting_id,
+        instance_id=instance_id,
+        type="cloud",
+        requested_at=datetime.now(timezone.utc),
+    )
+    await daily_recording_requests_controller.create(request)
+
+    # Verify request exists
+    match = await daily_recording_requests_controller.find_by_recording_id(recording_id)
+    assert match is not None
+    assert match[0] == meeting_id
+    assert match[1] == "cloud"
+
+    # Simulate webhook/polling storing cloud recording
+    success = await meetings_controller.set_cloud_recording_if_missing(
+        meeting_id=meeting_id,
+        s3_key="s3://bucket/recording.mp4",
+        duration=120,
+    )
+    assert success is True
+
+    # Verify meeting updated
+    updated_meeting = await meetings_controller.get_by_id(meeting_id)
+    assert updated_meeting.daily_composed_video_s3_key == "s3://bucket/recording.mp4"
+    assert updated_meeting.daily_composed_video_duration == 120
+
+
+@pytest.mark.asyncio
+async def test_recording_request_flow_raw_tracks(client):
+    """Test full raw-tracks recording flow: start -> webhook/polling -> process"""
+    # Create room and meeting
+    room = Room(
+        id="test-room-2",
+        name="Test Room 2",
+        slug="test-room-2",
+        user_id="test-user",
+    )
+    await rooms_controller.create(room)
+
+    meeting_id = f"meeting-{uuid4()}"
+    meeting = Meeting(
+        id=meeting_id,
+        room_name="test-room-2",
+        start_date=datetime.now(timezone.utc),
+        end_date=None,
+        recording_type="raw-tracks",
+    )
+    await meetings_controller.create(meeting)
+
+    # Simulate recording start
+    recording_id = "rec-raw-456"
+    instance_id = UUID("b1c2d3e4-f5a6-7890-abcd-ef1234567890")
+
+    request = DailyRecordingRequest(
+        recording_id=recording_id,
+        meeting_id=meeting_id,
+        instance_id=instance_id,
+        type="raw-tracks",
+        requested_at=datetime.now(timezone.utc),
+    )
+    await daily_recording_requests_controller.create(request)
+
+    # Simulate webhook/polling discovering recording
+    match = await daily_recording_requests_controller.find_by_recording_id(recording_id)
+    assert match is not None
+    found_meeting_id, recording_type = match
+    assert found_meeting_id == meeting_id
+    assert recording_type == "raw-tracks"
+
+    # Create recording (what webhook/polling does)
+    created = await recordings_controller.try_create_with_meeting(
+        Recording(
+            id=recording_id,
+            bucket_name="test-bucket",
+            object_key="recordings/20260120/",
+            recorded_at=datetime.now(timezone.utc),
+            track_keys=["track1.webm", "track2.webm"],
+            meeting_id=meeting_id,
+            status="pending",
+        )
+    )
+    assert created is True
+
+    # Verify recording exists with meeting_id
+    recording = await recordings_controller.get_by_id(recording_id)
+    assert recording is not None
+    assert recording.meeting_id == meeting_id
+    assert recording.status == "pending"
+    assert len(recording.track_keys) == 2
+
+
+@pytest.mark.asyncio
+async def test_stop_restart_creates_multiple_requests(client):
+    """Test stop/restart creates multiple request rows with same instance_id"""
+    # Create room and meeting
+    room = Room(
+        id="test-room-3",
+        name="Test Room 3",
+        slug="test-room-3",
+        user_id="test-user",
+    )
+    await rooms_controller.create(room)
+
+    meeting_id = f"meeting-{uuid4()}"
+    meeting = Meeting(
+        id=meeting_id,
+        room_name="test-room-3",
+        start_date=datetime.now(timezone.utc),
+        end_date=None,
+        recording_type="cloud",
+    )
+    await meetings_controller.create(meeting)
+
+    instance_id = UUID("c1d2e3f4-a5b6-7890-abcd-ef1234567890")
+
+    # First recording
+    await daily_recording_requests_controller.create(
+        DailyRecordingRequest(
+            recording_id="rec-first",
+            meeting_id=meeting_id,
+            instance_id=instance_id,
+            type="cloud",
+            requested_at=datetime.now(timezone.utc),
+        )
+    )
+
+    # Stop, then restart (new recording_id, same instance_id)
+    await daily_recording_requests_controller.create(
+        DailyRecordingRequest(
+            recording_id="rec-second",  # DIFFERENT
+            meeting_id=meeting_id,
+            instance_id=instance_id,  # SAME
+            type="cloud",
+            requested_at=datetime.now(timezone.utc),
+        )
+    )
+
+    # Both exist
+    requests = await daily_recording_requests_controller.get_by_meeting_id(meeting_id)
+    assert len(requests) == 2
+    assert {r.recording_id for r in requests} == {"rec-first", "rec-second"}
+    assert all(r.instance_id == instance_id for r in requests)
+
+
+@pytest.mark.asyncio
+async def test_orphan_recording_no_request(client):
+    """Test orphan recording (no request found)"""
+    # Simulate polling discovering recording with no request
+    recording_id = "rec-orphan"
+
+    match = await daily_recording_requests_controller.find_by_recording_id(recording_id)
+    assert match is None  # No request
+
+    # Mark as orphan
+    created = await recordings_controller.create_orphan(
+        Recording(
+            id=recording_id,
+            bucket_name="test-bucket",
+            object_key="orphan-key",
+            recorded_at=datetime.now(timezone.utc),
+            meeting_id=None,
+            status="orphan",
+            track_keys=None,
+        )
+    )
+    assert created is True
+
+    # Verify orphan exists
+    recording = await recordings_controller.get_by_id(recording_id)
+    assert recording is not None
+    assert recording.status == "orphan"
+    assert recording.meeting_id is None
+
+    # Second poll - already exists
+    created_again = await recordings_controller.create_orphan(
+        Recording(
+            id=recording_id,
+            bucket_name="test-bucket",
+            object_key="orphan-key",
+            recorded_at=datetime.now(timezone.utc),
+            meeting_id=None,
+            status="orphan",
+            track_keys=None,
+        )
+    )
+    assert created_again is False  # Already exists
+
+
+@pytest.mark.asyncio
+async def test_concurrent_polling_deduplication(client):
+    """Test concurrent pollers only queue once"""
+    # Create room and meeting
+    room = Room(
+        id="test-room-4",
+        name="Test Room 4",
+        slug="test-room-4",
+        user_id="test-user",
+    )
+    await rooms_controller.create(room)
+
+    meeting_id = f"meeting-{uuid4()}"
+    meeting = Meeting(
+        id=meeting_id,
+        room_name="test-room-4",
+        start_date=datetime.now(timezone.utc),
+        end_date=None,
+        recording_type="raw-tracks",
+    )
+    await meetings_controller.create(meeting)
+
+    # Create request
+    recording_id = "rec-concurrent"
+    await daily_recording_requests_controller.create(
+        DailyRecordingRequest(
+            recording_id=recording_id,
+            meeting_id=meeting_id,
+            instance_id=UUID("d1e2f3a4-b5c6-7890-abcd-ef1234567890"),
+            type="raw-tracks",
+            requested_at=datetime.now(timezone.utc),
+        )
+    )
+
+    # Poller 1
+    created1 = await recordings_controller.try_create_with_meeting(
+        Recording(
+            id=recording_id,
+            bucket_name="test-bucket",
+            object_key="test-key",
+            recorded_at=datetime.now(timezone.utc),
+            meeting_id=meeting_id,
+            status="pending",
+            track_keys=["track1.webm"],
+        )
+    )
+    assert created1 is True  # First wins
+
+    # Poller 2 (concurrent)
+    created2 = await recordings_controller.try_create_with_meeting(
+        Recording(
+            id=recording_id,
+            bucket_name="test-bucket",
+            object_key="test-key",
+            recorded_at=datetime.now(timezone.utc),
+            meeting_id=meeting_id,
+            status="pending",
+            track_keys=["track1.webm"],
+        )
+    )
+    assert created2 is False  # Conflict, skip
+
+    # Only one recording exists
+    recording = await recordings_controller.get_by_id(recording_id)
+    assert recording is not None
+    assert recording.meeting_id == meeting_id

server/tests/test_time_based_meeting_matching.py

@@ -1,374 +0,0 @@
-"""
-Integration tests for time-based meeting-to-recording matching.
-
-Tests the critical path for matching Daily.co recordings to meetings when
-API doesn't return instanceId.
-"""
-
-from datetime import datetime, timedelta, timezone
-
-import pytest
-
-from reflector.db.meetings import meetings_controller
-from reflector.db.rooms import rooms_controller
-
-
-@pytest.fixture
-async def test_room():
-    """Create a test room for meetings."""
-    room = await rooms_controller.add(
-        name="test-room-time",
-        user_id="test-user-id",
-        zulip_auto_post=False,
-        zulip_stream="",
-        zulip_topic="",
-        is_locked=False,
-        room_mode="normal",
-        recording_type="cloud",
-        recording_trigger="automatic",
-        is_shared=False,
-        platform="daily",
-    )
-    return room
-
-
-@pytest.fixture
-def base_time():
-    """Fixed timestamp for deterministic tests."""
-    return datetime(2026, 1, 14, 9, 0, 0, tzinfo=timezone.utc)
-
-
-class TestTimeBasedMatching:
-    """Test get_by_room_name_and_time() matching logic."""
-
-    async def test_exact_time_match(self, test_room, base_time):
-        """Recording timestamp exactly matches meeting start_date."""
-        meeting = await meetings_controller.create(
-            id="meeting-exact",
-            room_name="daily-test-20260114090000",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        result = await meetings_controller.get_by_room_name_and_time(
-            room_name="daily-test-20260114090000",
-            recording_start=base_time,
-            time_window_hours=168,
-        )
-
-        assert result is not None
-        assert result.id == meeting.id
-
-    async def test_recording_slightly_after_meeting_start(self, test_room, base_time):
-        """Recording started 1 minute after meeting (participants joined late)."""
-        meeting = await meetings_controller.create(
-            id="meeting-late",
-            room_name="daily-test-20260114090100",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        recording_start = base_time + timedelta(minutes=1)
-
-        result = await meetings_controller.get_by_room_name_and_time(
-            room_name="daily-test-20260114090100",
-            recording_start=recording_start,
-            time_window_hours=168,
-        )
-
-        assert result is not None
-        assert result.id == meeting.id
-
-    async def test_duplicate_room_names_picks_closest(self, test_room, base_time):
-        """
-        Two meetings with same room_name (duplicate/race condition).
-        Should pick closest by timestamp.
-        """
-        meeting1 = await meetings_controller.create(
-            id="meeting-1-first",
-            room_name="daily-duplicate-room",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        meeting2 = await meetings_controller.create(
-            id="meeting-2-second",
-            room_name="daily-duplicate-room",  # Same room_name!
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time + timedelta(seconds=0.99),  # 0.99s later
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        # Recording started 0.5s after meeting1
-        # Distance: meeting1 = 0.5s, meeting2 = 0.49s → meeting2 is closer
-        recording_start = base_time + timedelta(seconds=0.5)
-
-        result = await meetings_controller.get_by_room_name_and_time(
-            room_name="daily-duplicate-room",
-            recording_start=recording_start,
-            time_window_hours=168,
-        )
-
-        assert result is not None
-        assert result.id == meeting2.id  # meeting2 is closer (0.49s vs 0.5s)
-
-    async def test_outside_time_window_returns_none(self, test_room, base_time):
-        """Recording outside 1-week window returns None."""
-        await meetings_controller.create(
-            id="meeting-old",
-            room_name="daily-test-old",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        # Recording 8 days later (outside 7-day window)
-        recording_start = base_time + timedelta(days=8)
-
-        result = await meetings_controller.get_by_room_name_and_time(
-            room_name="daily-test-old",
-            recording_start=recording_start,
-            time_window_hours=168,
-        )
-
-        assert result is None
-
-    async def test_tie_breaker_deterministic(self, test_room, base_time):
-        """When time delta identical, tie-breaker by meeting.id is deterministic."""
-        meeting_z = await meetings_controller.create(
-            id="zzz-last-uuid",
-            room_name="daily-test-tie",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        meeting_a = await meetings_controller.create(
-            id="aaa-first-uuid",
-            room_name="daily-test-tie",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,  # Exact same start_date
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        result = await meetings_controller.get_by_room_name_and_time(
-            room_name="daily-test-tie",
-            recording_start=base_time,
-            time_window_hours=168,
-        )
-
-        assert result is not None
-        # Tie-breaker: lexicographically first UUID
-        assert result.id == "aaa-first-uuid"
-
-    async def test_timezone_naive_datetime_raises(self, test_room, base_time):
-        """Timezone-naive datetime raises ValueError."""
-        await meetings_controller.create(
-            id="meeting-tz",
-            room_name="daily-test-tz",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        # Naive datetime (no timezone)
-        naive_dt = datetime(2026, 1, 14, 9, 0, 0)
-
-        with pytest.raises(ValueError, match="timezone-aware"):
-            await meetings_controller.get_by_room_name_and_time(
-                room_name="daily-test-tz",
-                recording_start=naive_dt,
-                time_window_hours=168,
-            )
-
-    async def test_one_week_boundary_after_included(self, test_room, base_time):
-        """Meeting 1-week AFTER recording is included (window_end boundary)."""
-        meeting_time = base_time + timedelta(hours=168)
-
-        await meetings_controller.create(
-            id="meeting-boundary-after",
-            room_name="daily-test-boundary-after",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=meeting_time,
-            end_date=meeting_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        result = await meetings_controller.get_by_room_name_and_time(
-            room_name="daily-test-boundary-after",
-            recording_start=base_time,
-            time_window_hours=168,
-        )
-
-        assert result is not None
-        assert result.id == "meeting-boundary-after"
-
-    async def test_one_week_boundary_before_included(self, test_room, base_time):
-        """Meeting 1-week BEFORE recording is included (window_start boundary)."""
-        meeting_time = base_time - timedelta(hours=168)
-
-        await meetings_controller.create(
-            id="meeting-boundary-before",
-            room_name="daily-test-boundary-before",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=meeting_time,
-            end_date=meeting_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        result = await meetings_controller.get_by_room_name_and_time(
-            room_name="daily-test-boundary-before",
-            recording_start=base_time,
-            time_window_hours=168,
-        )
-
-        assert result is not None
-        assert result.id == "meeting-boundary-before"
-
-    async def test_recording_before_meeting_start(self, test_room, base_time):
-        """Recording started before meeting (clock skew or early join)."""
-        await meetings_controller.create(
-            id="meeting-early",
-            room_name="daily-test-early",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        recording_start = base_time - timedelta(minutes=2)
-
-        result = await meetings_controller.get_by_room_name_and_time(
-            room_name="daily-test-early",
-            recording_start=recording_start,
-            time_window_hours=168,
-        )
-
-        assert result is not None
-        assert result.id == "meeting-early"
-
-    async def test_mixed_inside_outside_window(self, test_room, base_time):
-        """Multiple meetings, only one inside window - returns the inside one."""
-        await meetings_controller.create(
-            id="meeting-old",
-            room_name="daily-test-mixed",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time - timedelta(days=10),
-            end_date=base_time - timedelta(days=10, hours=-1),
-            room=test_room,
-        )
-
-        await meetings_controller.create(
-            id="meeting-inside",
-            room_name="daily-test-mixed",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time - timedelta(days=2),
-            end_date=base_time - timedelta(days=2, hours=-1),
-            room=test_room,
-        )
-
-        await meetings_controller.create(
-            id="meeting-future",
-            room_name="daily-test-mixed",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time + timedelta(days=10),
-            end_date=base_time + timedelta(days=10, hours=1),
-            room=test_room,
-        )
-
-        result = await meetings_controller.get_by_room_name_and_time(
-            room_name="daily-test-mixed",
-            recording_start=base_time,
-            time_window_hours=168,
-        )
-
-        assert result is not None
-        assert result.id == "meeting-inside"
-
-
-class TestAtomicCloudRecordingUpdate:
-    """Test atomic update prevents race conditions."""
-
-    async def test_first_update_succeeds(self, test_room, base_time):
-        """First call to set_cloud_recording_if_missing succeeds."""
-        meeting = await meetings_controller.create(
-            id="meeting-atomic-1",
-            room_name="daily-test-atomic",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        success = await meetings_controller.set_cloud_recording_if_missing(
-            meeting_id=meeting.id,
-            s3_key="first-s3-key",
-            duration=100,
-        )
-
-        assert success is True
-
-        updated = await meetings_controller.get_by_id(meeting.id)
-        assert updated.daily_composed_video_s3_key == "first-s3-key"
-        assert updated.daily_composed_video_duration == 100
-
-    async def test_second_update_fails_atomically(self, test_room, base_time):
-        """Second call to update same meeting doesn't overwrite (atomic check)."""
-        meeting = await meetings_controller.create(
-            id="meeting-atomic-2",
-            room_name="daily-test-atomic2",
-            room_url="https://example.daily.co/test",
-            host_room_url="https://example.daily.co/test?t=host",
-            start_date=base_time,
-            end_date=base_time + timedelta(hours=1),
-            room=test_room,
-        )
-
-        success1 = await meetings_controller.set_cloud_recording_if_missing(
-            meeting_id=meeting.id,
-            s3_key="first-s3-key",
-            duration=100,
-        )
-
-        assert success1 is True
-
-        after_first = await meetings_controller.get_by_id(meeting.id)
-        assert after_first.daily_composed_video_s3_key == "first-s3-key"
-
-        success2 = await meetings_controller.set_cloud_recording_if_missing(
-            meeting_id=meeting.id,
-            s3_key="bucket/path/should-not-overwrite",
-            duration=200,
-        )
-
-        assert success2 is False
-
-        final = await meetings_controller.get_by_id(meeting.id)
-        assert final.daily_composed_video_s3_key == "first-s3-key"
-        assert final.daily_composed_video_duration == 100

server/tests/test_transcripts_rtc_ws.py

@@ -115,7 +115,9 @@ def appserver(tmpdir, setup_database, celery_session_app, celery_session_worker)
     settings.DATA_DIR = DATA_DIR
 
 
-# Using celery_includes from conftest.py which includes both pipelines
+@pytest.fixture(scope="session")
+def celery_includes():
+    return ["reflector.pipelines.main_live_pipeline"]
 
 
 @pytest.mark.usefixtures("setup_database")

server/tests/test_user_websocket_auth.py

@@ -56,12 +56,7 @@ def appserver_ws_user(setup_database):
 
     if server_instance:
         server_instance.should_exit = True
-        server_thread.join(timeout=2.0)
-
-    # Reset global singleton for test isolation
-    from reflector.ws_manager import reset_ws_manager
-
-    reset_ws_manager()
+        server_thread.join(timeout=30)
 
 
 @pytest.fixture(autouse=True)
@@ -138,8 +133,6 @@ async def test_user_ws_accepts_valid_token_and_receives_events(appserver_ws_user
 
     # Connect and then trigger an event via HTTP create
     async with aconnect_ws(base_ws, subprotocols=subprotocols) as ws:
-        await asyncio.sleep(0.2)
-
         # Emit an event to the user's room via a standard HTTP action
         from httpx import AsyncClient
 
@@ -157,7 +150,6 @@ async def test_user_ws_accepts_valid_token_and_receives_events(appserver_ws_user
             "email": "user-abc@example.com",
         }
 
-        # Use in-memory client (global singleton makes it share ws_manager)
         async with AsyncClient(app=app, base_url=f"http://{host}:{port}/v1") as ac:
             # Create a transcript as this user so that the server publishes TRANSCRIPT_CREATED to user room
             resp = await ac.post("/transcripts", json={"name": "WS Test"})

www/app/[roomName]/components/DailyRoom.tsx

@@ -8,7 +8,7 @@ import {
   useRef,
   useState,
 } from "react";
-import { Box, Spinner, Center, Text, Button, VStack } from "@chakra-ui/react";
+import { Box, Spinner, Center, Text } from "@chakra-ui/react";
 import { useRouter, useParams } from "next/navigation";
 import DailyIframe, {
   DailyCall,
@@ -16,13 +16,10 @@ import DailyIframe, {
   DailyCustomTrayButton,
   DailyCustomTrayButtons,
   DailyEventObjectCustomButtonClick,
-  DailyEventObjectFatalError,
-  DailyFatalErrorType,
   DailyFactoryOptions,
   DailyParticipantsObject,
 } from "@daily-co/daily-js";
 import type { components } from "../../reflector-api";
-import { printApiError, ApiError } from "../../api/_error";
 import { useAuth } from "../../lib/AuthProvider";
 import { useConsentDialog } from "../../lib/consent";
 import {
@@ -48,63 +45,6 @@ const RAW_TRACKS_NAMESPACE = "a1b2c3d4-e5f6-7890-abcd-ef1234567890";
 const RECORDING_START_DELAY_MS = 2000;
 const RECORDING_START_MAX_RETRIES = 5;
 
-const FATAL_ERROR_MESSAGES: Partial<
-  Record<DailyFatalErrorType, { message: string; rejoinable?: boolean }>
-> = {
-  "connection-error": {
-    message: "Connection lost. Please check your network.",
-    rejoinable: true,
-  },
-  "exp-room": { message: "The meeting time has ended." },
-  "exp-token": { message: "Your session has expired.", rejoinable: true },
-  ejected: { message: "You were removed from this meeting." },
-  "meeting-full": { message: "This meeting is full." },
-  "not-allowed": { message: "You are not allowed to join this meeting." },
-  "nbf-room": { message: "This meeting hasn't started yet." },
-  "nbf-token": { message: "This meeting hasn't started yet." },
-  "no-room": { message: "This room does not exist." },
-  "end-of-life": { message: "This meeting room is no longer available." },
-};
-
-function FatalErrorScreen({
-  error,
-  roomName,
-}: {
-  error: FatalError;
-  roomName: string;
-}) {
-  const router = useRouter();
-  const info =
-    error.type !== "unknown" ? FATAL_ERROR_MESSAGES[error.type] : undefined;
-  const message = info?.message ?? `Something went wrong: ${error.message}`;
-  const rejoinable = info?.rejoinable ?? false;
-
-  return (
-    <Center width="100vw" height="100vh">
-      <VStack gap={4}>
-        <Text color="red.500">{message}</Text>
-        {rejoinable ? (
-          <>
-            <Button onClick={() => window.location.reload()}>
-              Try Rejoining
-            </Button>
-            <Button
-              variant="outline"
-              onClick={() => router.push(`/${roomName}`)}
-            >
-              Leave
-            </Button>
-          </>
-        ) : (
-          <Button onClick={() => router.push(`/${roomName}`)}>
-            Back to Room
-          </Button>
-        )}
-      </VStack>
-    </Center>
-  );
-}
-
 type Meeting = components["schemas"]["Meeting"];
 type Room = components["schemas"]["RoomDetails"];
 
@@ -142,8 +82,6 @@ const USE_FRAME_INIT_STATE = {
   joined: false as boolean,
 } as const;
 
-type FatalError = { type: DailyFatalErrorType | "unknown"; message: string };
-
 // Daily js and not Daily react used right now because daily-js allows for prebuild interface vs. -react is customizable but has no nice defaults
 const useFrame = (
   container: HTMLDivElement | null,
@@ -151,7 +89,6 @@ const useFrame = (
     onLeftMeeting: () => void;
     onCustomButtonClick: (ev: DailyEventObjectCustomButtonClick) => void;
     onJoinMeeting: () => void;
-    onError: (ev: DailyEventObjectFatalError) => void;
   },
 ) => {
   const [{ frame, joined }, setState] = useState(USE_FRAME_INIT_STATE);
@@ -197,7 +134,6 @@ const useFrame = (
     if (!frame) return;
     frame.on("left-meeting", cbs.onLeftMeeting);
     frame.on("custom-button-click", cbs.onCustomButtonClick);
-    frame.on("error", cbs.onError);
     const joinCb = () => {
       if (!frame) {
         console.error("frame is null in joined-meeting callback");
@@ -209,7 +145,6 @@ const useFrame = (
     return () => {
       frame.off("left-meeting", cbs.onLeftMeeting);
       frame.off("custom-button-click", cbs.onCustomButtonClick);
-      frame.off("error", cbs.onError);
       frame.off("joined-meeting", joinCb);
     };
   }, [frame, cbs]);
@@ -253,7 +188,6 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
   const joinMutation = useRoomJoinMeeting();
   const startRecordingMutation = useMeetingStartRecording();
   const [joinedMeeting, setJoinedMeeting] = useState<Meeting | null>(null);
-  const [fatalError, setFatalError] = useState<FatalError | null>(null);
 
   // Generate deterministic instanceIds so all participants use SAME IDs
   const cloudInstanceId = parseNonEmptyString(meeting.id);
@@ -300,18 +234,8 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
   const roomUrl = joinedMeeting?.room_url;
 
   const handleLeave = useCallback(() => {
-    // If a fatal error occurred, don't redirect — let the error UI show
-    if (fatalError) return;
     router.push("/browse");
-  }, [router, fatalError]);
-
-  const handleError = useCallback((ev: DailyEventObjectFatalError) => {
-    const error: FatalError = {
-      type: ev.error?.type ?? "unknown",
-      message: ev.errorMsg,
-    };
-    setFatalError(error);
-  }, []);
+  }, [router]);
 
   const handleCustomButtonClick = useCallback(
     (ev: DailyEventObjectCustomButtonClick) => {
@@ -400,7 +324,6 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
     onLeftMeeting: handleLeave,
     onCustomButtonClick: handleCustomButtonClick,
     onJoinMeeting: handleFrameJoinMeeting,
-    onError: handleError,
   });
 
   useEffect(() => {
@@ -457,27 +380,13 @@ export default function DailyRoom({ meeting, room }: DailyRoomProps) {
   }
 
   if (joinMutation.isError) {
-    const apiDetail = printApiError(
-      joinMutation.error as /*ref 095959E6-01CC-4CF0-B3A9-F65F12F046D3*/ ApiError,
-    );
     return (
       <Center width="100vw" height="100vh">
-        <VStack gap={4}>
-          <Text color="red.500">
-            {apiDetail ?? "Failed to join meeting. Please try again."}
-          </Text>
-          <Button onClick={() => router.push(`/${roomName}`)}>
-            Back to Room
-          </Button>
-        </VStack>
+        <Text color="red.500">Failed to join meeting. Please try again.</Text>
       </Center>
     );
   }
 
-  if (fatalError) {
-    return <FatalErrorScreen error={fatalError} roomName={roomName} />;
-  }
-
   if (!roomUrl) {
     return null;
   }

www/app/lib/apiHooks.ts

@@ -9,7 +9,6 @@ import { MeetingId } from "./types";
 import { NonEmptyString } from "./utils";
 
 /*
- * ref 095959E6-01CC-4CF0-B3A9-F65F12F046D3
  * XXX error types returned from the hooks are not always correct; declared types are ValidationError but real type could be string or any other
  * this is either a limitation or incorrect usage of Python json schema generator
  * or, limitation or incorrect usage of .d type generator from json schema