refactor(speaker): scope a request by the tenant it declares, not by an id prefix

A speaker id was minted as `user_{tenant}_...` in three unrelated places, and
the WebUI treated that prefix as access control:

    const userPrefix = `user_${user.id}_`
    if (!speakerId.startsWith(userPrefix)) {
      alert('You can only delete your own speakers.')

Deciding permission by string-matching a naming convention only holds while the
convention does. It already did not: moving the tenant to Chronicle's user id
left all 51 live speakers with ids reading `user_1_` and an owner of
`69b80e5894aa9ec334a421c9`, so the Speakers page filtered its own gallery down
to nothing and every delete was refused.

Ids are now opaque (`speaker_{uuid}`) and ownership is only ever
`speakers.user_id`. The three by-id endpoints plus `/enroll/append` take the
tenant the caller is acting for and 404 on a mismatch — 404 rather than 403 so
a refusal does not confirm the speaker exists. The service still has no caller
authentication, so this bounds mistakes, not attackers; the WebUI's alert
claimed a guarantee that was never enforced anywhere.

Existing ids keep their prefix. It is inert now, and renaming them would have
to move on-disk enrollment/quarantine directories, relative paths stored in
`speaker_audio_segments`, per-speaker manifests, and denormalized copies in
four Mongo collections plus `User.wakeword_allowed_speakers` — where a missed
rewrite silently disables the wake-word gate rather than failing.

The WebUI can no longer mint a tenant from a typed username: this service
cannot invent a Chronicle user id, so the selector only picks among tenants
that already have speaker data.

Author: AnkushMalaker

backends/advanced/src/advanced_omi_backend/controllers/guided_enrollment_controller.py

@@ -690,7 +690,7 @@ async def decide_clips(user: User, speaker_name: str, decisions: List[dict]):
                     raise ValueError(f"No enrolled speaker named '{enrollment_target}'")
                 wav = await reconstruct_audio_segment(conversation_id, start, end)
                 result = await speaker_client.append_to_speaker(
-                    target_gallery["speaker_id"], wav
+                    target_gallery["speaker_id"], wav, user_id=str(user.user_id)
                 )
                 if result.get("error"):
                     enroll_error = result["error"]
@@ -954,7 +954,7 @@ async def reset_speaker_state(
         gallery = await _gallery_stats(speaker_client, speaker_name, str(user.user_id))
         if gallery:
             result = await speaker_client.delete_speaker(
-                gallery["speaker_id"], delete_audio=True
+                gallery["speaker_id"], user_id=str(user.user_id), delete_audio=True
             )
             if result.get("error"):
                 return JSONResponse(

backends/advanced/src/advanced_omi_backend/routers/modules/finetuning_routes.py

@@ -454,7 +454,9 @@ async def enroll_selected_clips(
             )
             if existing:
                 result = await speaker_client.append_to_speaker(
-                    speaker_id=existing["id"], audio_data=wav_bytes
+                    speaker_id=existing["id"],
+                    audio_data=wav_bytes,
+                    user_id=str(current_user.user_id),
                 )
                 if "error" in result:
                     failed += 1

backends/advanced/src/advanced_omi_backend/speaker_recognition_client.py

@@ -1511,8 +1511,8 @@ async def enroll_new_speaker(
             return {"error": "speaker_recognition_disabled"}
 
         try:
-            # Generate speaker ID: user_{user_id}_speaker_{random_hex}
-            speaker_id = f"user_{user_id}_speaker_{uuid.uuid4().hex[:12]}"
+            # Opaque: the tenant is the `user_id` field, not part of the id.
+            speaker_id = f"speaker_{uuid.uuid4().hex[:12]}"
 
             logger.info(
                 f"🎤 Enrolling new speaker '{speaker_name}' with ID: {speaker_id}"
@@ -1558,20 +1558,25 @@ async def enroll_new_speaker(
             logger.error(f"🎤 ❌ Error enrolling speaker: {e}")
             return {"error": "unknown_error", "message": str(e)}
 
-    async def append_to_speaker(self, speaker_id: str, audio_data: bytes) -> Dict:
+    async def append_to_speaker(
+        self, speaker_id: str, audio_data: bytes, user_id: str
+    ) -> Dict:
         """
         Append audio to existing speaker's embedding (fine-tuning).
 
         Args:
             speaker_id: ID of existing speaker
             audio_data: WAV audio bytes
+            user_id: Tenant the speaker must belong to
 
         Returns:
             Response dict from append endpoint
         """
         if not self.enabled:
             logger.warning("🎤 Speaker recognition disabled, cannot append to speaker")
             return {"error": "speaker_recognition_disabled"}
+        if not user_id:
+            raise ValueError("user_id is required to append to a speaker")
 
         try:
             logger.info(f"🎤 Appending audio to speaker: {speaker_id}")
@@ -1585,6 +1590,7 @@ async def append_to_speaker(self, speaker_id: str, audio_data: bytes) -> Dict:
                     content_type="audio/wav",
                 )
                 form_data.add_field("speaker_id", speaker_id)
+                form_data.add_field("user_id", user_id)
 
                 async with session.post(
                     f"{self.service_url}/enroll/append",
@@ -1731,15 +1737,22 @@ async def delete_enrollment_segment(
             logger.error(f"🎤 Failed to delete enrollment segment: {e}")
             return {"error": "connection_failed", "message": str(e)}
 
-    async def delete_speaker(self, speaker_id: str, delete_audio: bool = True) -> Dict:
+    async def delete_speaker(
+        self, speaker_id: str, user_id: str, delete_audio: bool = True
+    ) -> Dict:
         """Delete an enrolled speaker (and, by default, their enrollment audio)."""
         if not self.enabled:
             return {"error": "speaker_recognition_disabled"}
+        if not user_id:
+            raise ValueError("user_id is required to delete a speaker")
         try:
             async with aiohttp.ClientSession() as session:
                 async with session.delete(
                     f"{self.service_url}/speakers/{speaker_id}",
-                    params={"delete_audio": "true" if delete_audio else "false"},
+                    params={
+                        "user_id": user_id,
+                        "delete_audio": "true" if delete_audio else "false",
+                    },
                     timeout=aiohttp.ClientTimeout(total=30),
                 ) as response:
                     if response.status != 200:

backends/advanced/src/advanced_omi_backend/workers/finetuning_jobs.py

@@ -150,7 +150,9 @@ async def run_speaker_finetuning_job() -> dict:
 
             if existing_speaker:
                 result = await speaker_client.append_to_speaker(
-                    speaker_id=existing_speaker["id"], audio_data=wav_bytes
+                    speaker_id=existing_speaker["id"],
+                    audio_data=wav_bytes,
+                    user_id=conversation.user_id,
                 )
                 if "error" in result:
                     failed += 1

extras/ml-experiments/experiments/pyannote_diarization_validation/enroll_and_identify.py

@@ -58,7 +58,7 @@ def main():
         buf = io.BytesIO()
         sf.write(buf, clip, SR, format="WAV", subtype="PCM_16")
         buf.seek(0)
-        sid = f"user_{USER}_{meeting}_{spk}"
+        sid = f"{meeting}_{spk}"
         r = requests.post(
             f"{SVC}/enroll/upload",
             files={"file": ("enroll.wav", buf, "audio/wav")},

extras/speaker-recognition/laptop_client.py

@@ -182,9 +182,11 @@ async def list_speakers(self):
         result = await self._request("GET", "/speakers")
         return result.get("speakers", [])
 
-    async def remove_speaker(self, speaker_id: str):
+    async def remove_speaker(self, speaker_id: str, user_id: str):
         """Remove an enrolled speaker."""
-        return await self._request("DELETE", f"/speakers/{speaker_id}")
+        return await self._request(
+            "DELETE", f"/speakers/{speaker_id}", params={"user_id": user_id}
+        )
 
 
 async def record_audio(duration: float, sample_rate: int = 16000) -> str:
@@ -418,7 +420,7 @@ async def cmd_remove(args):
             await client.health_check()
 
             # Remove speaker
-            result = await client.remove_speaker(args.speaker_id)
+            result = await client.remove_speaker(args.speaker_id, args.user_id)
 
             if result.get("deleted"):
                 logger.info(f"✅ Successfully removed speaker: {args.speaker_id}")
@@ -584,6 +586,9 @@ def main():
     remove_parser.add_argument(
         "--speaker-id", required=True, help="Speaker ID to remove"
     )
+    remove_parser.add_argument(
+        "--user-id", required=True, help="Chronicle user id owning the speaker"
+    )
 
     # Diarize command
     diarize_parser = subparsers.add_parser(

extras/speaker-recognition/scripts/enroll_speaker.py

@@ -288,10 +288,14 @@ def list_speakers(service_url: str = SPEAKER_SERVICE_URL) -> bool:
         return False
 
 
-def delete_speaker(speaker_id: str, service_url: str = SPEAKER_SERVICE_URL) -> bool:
+def delete_speaker(
+    speaker_id: str, user_id: str, service_url: str = SPEAKER_SERVICE_URL
+) -> bool:
     """Delete an enrolled speaker."""
     try:
-        response = requests.delete(f"{service_url}/speakers/{speaker_id}")
+        response = requests.delete(
+            f"{service_url}/speakers/{speaker_id}", params={"user_id": user_id}
+        )
         if response.status_code == 200:
             logger.info(f"✅ Successfully deleted speaker: {speaker_id}")
             return True
@@ -328,7 +332,8 @@ def main():
     # Speaker info arguments
     parser.add_argument("--id", help="Speaker ID (required for enrollment)")
     parser.add_argument(
-        "--user-id", help="Chronicle user id owning the speaker (required to enroll)"
+        "--user-id",
+        help="Chronicle user id owning the speaker (required to enroll or delete)",
     )
     parser.add_argument("--name", help="Speaker display name (required for enrollment)")
 
@@ -357,7 +362,10 @@ def main():
         return 0 if list_speakers(service_url) else 1
 
     elif args.delete:
-        return 0 if delete_speaker(args.delete, service_url) else 1
+        if not args.user_id:
+            logger.error("❌ --user-id is required to delete a speaker")
+            return 1
+        return 0 if delete_speaker(args.delete, args.user_id, service_url) else 1
 
     else:
         # Enrollment actions require ID and name

extras/speaker-recognition/src/simple_speaker_recognition/api/core/__init__.py

@@ -3,6 +3,7 @@
 from .utils import (
     get_data_directory,
     owner_of_speaker,
+    require_speaker_owner,
     safe_format_confidence,
     secure_temp_file,
     validate_confidence,
@@ -13,5 +14,6 @@
     "safe_format_confidence",
     "secure_temp_file",
     "owner_of_speaker",
+    "require_speaker_owner",
     "validate_confidence",
 ]

extras/speaker-recognition/src/simple_speaker_recognition/api/core/utils.py

@@ -106,18 +106,9 @@ def secure_temp_file(suffix: str = ".wav") -> tempfile._TemporaryFileWrapper:
 
 
 def owner_of_speaker(speaker_id: str) -> str:
-    """Return the tenant that owns ``speaker_id``, from the speaker's own record.
-
-    ``speakers.user_id`` is the ownership record, so it is the only thing consulted.
-    This used to parse the tenant out of the id — ``int(speaker_id.split("_")[1])`` —
-    which the audit flags as inferring a tenant from a SpeakerId: the
-    ``user_{user_id}_speaker_{...}`` shape is a naming convention, not a fact, and it
-    is wrong for a speaker that was imported or created by a client that names ids
-    differently. It also stopped parsing entirely once a tenant became a Chronicle
-    ObjectId rather than an integer.
-
-    Only for speakers that already exist. Enrolment creates one, so it takes an
-    explicit ``user_id`` instead of leaving the service to guess.
+    """Return the tenant that owns ``speaker_id``, read from ``speakers.user_id``.
+
+    A speaker id is opaque. Nothing about the tenant is inferred from its text.
     """
 
     # Imported here rather than at module scope: database.queries imports the API
@@ -135,6 +126,24 @@ def owner_of_speaker(speaker_id: str) -> str:
         db.close()
 
 
+def require_speaker_owner(speaker_id: str, user_id: str) -> str:
+    """Return ``user_id`` if it owns ``speaker_id``, else 404.
+
+    Scopes a request to the tenant the caller says it is acting for, so a client
+    holding a stale or wrong tenant cannot reach another tenant's speaker. The
+    service has no caller authentication, so this bounds mistakes, not attackers.
+    A mismatch is 404 rather than 403 to avoid confirming the speaker exists.
+    """
+
+    owner = owner_of_speaker(speaker_id)
+    if owner != user_id:
+        log.warning(
+            "Tenant %s requested speaker %s owned by %s", user_id, speaker_id, owner
+        )
+        raise HTTPException(404, f"Speaker not found: {speaker_id}")
+    return owner
+
+
 def validate_confidence(confidence: Any, context: str = "") -> float:
     """Validate and sanitize confidence values from speaker identification.
 

extras/speaker-recognition/src/simple_speaker_recognition/api/routers/enrollment.py

@@ -12,7 +12,7 @@
 from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
 from simple_speaker_recognition.api.core.utils import (
     get_data_directory,
-    owner_of_speaker,
+    require_speaker_owner,
     secure_temp_file,
 )
 from simple_speaker_recognition.core.unified_speaker_db import UnifiedSpeakerDB
@@ -538,11 +538,11 @@ async def enroll_append(
         ..., description="Multiple audio files to append to existing speaker"
     ),
     speaker_id: str = Form(..., description="Existing speaker identifier"),
+    user_id: str = Form(..., description="Chronicle user id owning this speaker"),
     db: UnifiedSpeakerDB = Depends(get_db),
 ):
     """Append audio segments to an existing speaker, computing weighted average embedding."""
-    # The speaker must already exist, so its recorded owner is authoritative.
-    user_id = owner_of_speaker(speaker_id)
+    require_speaker_owner(speaker_id, user_id)
     log.info(
         f"Appending to speaker: {speaker_id} (User: {user_id}) with {len(files)} files"
     )