Normalize the WorkManager request id to Kolibri's supervisor_id form

The task worker stamped a job's supervisor_id with the WorkManager request
id in its canonical java.util.UUID.toString() (dashed) form, and the
reconciler built its live set the same way. But Kolibri's morango UUIDField
normalizes every stored supervisor_id to the dashless uuid4().hex form, and
the ownership fence compares stored-vs-expected owner as plain strings. So
after the claim write, the job's own completion/worker-info writes compared
unequal to the stored owner, were discarded as disowned, and the job was
stranded in RUNNING forever — the first-run setup task never completed, so
onboarding never reached the library (the Android smoke test's
"Welcome to Kolibri!" assertion).

Convert the request id to the dashless hex form via a shared
supervisor_id_from_request helper at both use sites (the ownership claim and
the reconcile live set) so they agree with each other and with what morango
stores. Add an end-to-end lifecycle test that runs a job through the real
storage and asserts it reaches COMPLETED with ownership cleared.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: rtibblesbot

platforms/android/app/src/main/python/task_identity.py

@@ -0,0 +1,15 @@
+"""Canonical supervisor-id form for the Android task layer."""
+
+import uuid
+
+
+def supervisor_id_from_request(request_id):
+    """
+    Convert a WorkManager request id to the form Kolibri stores as supervisor_id.
+
+    WorkManager gives dashed UUIDs; morango stores supervisor_id as dashless hex.
+    Both the claim (taskworker) and the reconcile live set (task_reconciler) must
+    normalize here, or a completion write looks disowned and strands the job in
+    RUNNING.
+    """
+    return uuid.UUID(str(request_id)).hex

platforms/android/app/src/main/python/task_reconciler.py

@@ -7,6 +7,7 @@
 import os
 
 from java import jclass
+from task_identity import supervisor_id_from_request
 
 from kolibri.core.tasks.job import State
 from kolibri.core.tasks.main import job_storage
@@ -26,7 +27,7 @@ def _extract_work_ids(work_infos):
     job_ids = set()
     request_ids = set()
     for work_info in work_infos:
-        request_ids.add(str(work_info.getId()))
+        request_ids.add(supervisor_id_from_request(work_info.getId()))
         tags = work_info.getTags()
         # Tags mix worker-class FQNs with our own; an explicit prefix identifies
         # ours rather than excluding known patterns.

platforms/android/app/src/main/python/taskworker.py

@@ -2,6 +2,8 @@
 import os
 import threading
 
+from task_identity import supervisor_id_from_request
+
 from kolibri.core.tasks.worker import execute_job as kolibri_execute_job
 
 logger = logging.getLogger(__name__)
@@ -31,7 +33,7 @@ def execute_job(job_id, request_id):
             worker_process=str(os.getpid()),
             worker_thread=str(threading.get_ident()),
             worker_extra=str(request_id),
-            supervisor_id=str(request_id),
+            supervisor_id=supervisor_id_from_request(request_id),
         )
         logger.info(
             "Completed Kolibri task worker for job {} (request {})".format(

platforms/android/app/src/main/python/tests/test_lifecycle.py

@@ -0,0 +1,33 @@
+"""
+End-to-end: a job dispatched via taskworker with a real (dashed) request id must
+reach COMPLETED against unmocked storage, exercising the ownership fence that the
+unit tests cannot (see task_identity for why normalization is load-bearing).
+"""
+
+from django.test import TestCase
+
+from kolibri.core.tasks.job import Job
+from kolibri.core.tasks.job import State
+from kolibri.core.tasks.main import job_storage
+
+
+def _noop_task(**kwargs):
+    return "ok"
+
+
+class TaskWorkerLifecycleTest(TestCase):
+    databases = "__all__"
+
+    def test_execute_via_request_id_reaches_completed(self):
+        import taskworker
+
+        job = Job(_noop_task)
+        job_id = job_storage.enqueue_job(job)
+
+        # A canonical (dashed) java.util.UUID.toString() request id.
+        taskworker.execute_job(job_id, "3f2504e0-4f89-41d3-9a0c-0305e82c3301")
+
+        orm_job = job_storage.get_orm_job(job_id)
+        self.assertEqual(orm_job.state, State.COMPLETED)
+        # Ownership is cleared on a terminal transition.
+        self.assertIsNone(orm_job.supervisor_id)

platforms/android/app/src/main/python/tests/test_task_identity.py

@@ -0,0 +1,14 @@
+from task_identity import supervisor_id_from_request
+
+HEX = "3f2504e04f8941d39a0c0305e82c3301"
+
+
+def test_dashed_request_id_normalized_to_hex():
+    assert (
+        supervisor_id_from_request("3f2504e0-4f89-41d3-9a0c-0305e82c3301")
+        == HEX
+    )
+
+
+def test_dashless_request_id_is_idempotent():
+    assert supervisor_id_from_request(HEX) == HEX

platforms/android/app/src/main/python/tests/test_task_reconciler.py

@@ -14,14 +14,14 @@ def _make_work_info(request_id, tags):
 def test_extract_work_ids_splits_job_ids_and_request_ids():
     work_infos = [
         _make_work_info(
-            "req-a",
+            "3f2504e0-4f89-41d3-9a0c-0305e82c3301",
             [
                 "kolibri:job:job-a",
                 "org.learningequality.Kolibri.task.TaskWorker",
             ],
         ),
         _make_work_info(
-            "req-b",
+            "5a3f8b2c-1d4e-4c6f-8a9b-0c1d2e3f4a5b",
             [
                 "kolibri:job:job-b",
                 "androidx.work.impl.workers.SomeWorker",
@@ -32,7 +32,11 @@ def test_extract_work_ids_splits_job_ids_and_request_ids():
     job_ids, request_ids = task_reconciler._extract_work_ids(work_infos)
 
     assert job_ids == {"job-a", "job-b"}
-    assert request_ids == {"req-a", "req-b"}
+    # Request ids are normalized to the dashless form Kolibri stores as owner.
+    assert request_ids == {
+        "3f2504e04f8941d39a0c0305e82c3301",
+        "5a3f8b2c1d4e4c6f8a9b0c1d2e3f4a5b",
+    }
 
 
 def test_do_reconciliation_reconciles_stalled_jobs_first_with_live_set():

platforms/android/app/src/main/python/tests/test_taskworker.py

@@ -2,21 +2,26 @@
 
 import taskworker
 
+# A canonical (dashed) java.util.UUID.toString() request id and its dashless
+# hex form, which is what Kolibri stores and compares as the supervisor_id.
+REQUEST_ID = "3f2504e0-4f89-41d3-9a0c-0305e82c3301"
+SUPERVISOR_ID = "3f2504e04f8941d39a0c0305e82c3301"
+
 
 def test_execute_job_claims_ownership_with_request_id():
     with mock.patch.object(taskworker, "kolibri_execute_job") as kej:
-        taskworker.execute_job("job-1", "req-9")
+        taskworker.execute_job("job-1", REQUEST_ID)
     _, kwargs = kej.call_args
-    assert kwargs["supervisor_id"] == "req-9"
+    assert kwargs["supervisor_id"] == SUPERVISOR_ID
 
 
 def test_execute_job_returns_true_on_success():
     with mock.patch.object(taskworker, "kolibri_execute_job"):
-        assert taskworker.execute_job("job-1", "req-9") is True
+        assert taskworker.execute_job("job-1", REQUEST_ID) is True
 
 
 def test_execute_job_returns_false_on_error():
     with mock.patch.object(
         taskworker, "kolibri_execute_job", side_effect=RuntimeError("boom")
     ):
-        assert taskworker.execute_job("job-1", "req-9") is False
+        assert taskworker.execute_job("job-1", REQUEST_ID) is False