fix(update): record terminal status when the update job is cancelled

Cancellation lands on the job's await points and skipped the failure
handler, releasing the update lock while the status file still said
RUNNING. Catch CancelledError, write a terminal FAILED status, and
re-raise.

Author: elkaix

src/pythinker_code/ui/shell/update_orchestrator.py

@@ -443,6 +443,27 @@ async def run_update_job(
             )
         )
         return reported_result
+    except asyncio.CancelledError:
+        # Cancellation lands on the await points (do_update, the smoke-check
+        # thread, retry sleeps) and would otherwise skip the failure handler
+        # below, releasing the lock with the job still recorded as RUNNING —
+        # a stale "in progress" status with no process behind it. Record a
+        # terminal state, then propagate. The smoke-check subprocess is not
+        # interrupted mid-flight, but its own timeout bounds it.
+        message = "Update job cancelled."
+        append_update_log(message)
+        write_update_status(
+            _new_status(
+                job_id=job_id,
+                state=UpdateJobState.FAILED,
+                source=source,
+                started_at=started_at,
+                finished_at=time.time(),
+                result=UpdateResult.FAILED.name,
+                message=message,
+            )
+        )
+        raise
     except Exception as exc:
         message = f"Update failed: {exc}"
         append_update_log(message)

tests/ui_and_conv/test_update_orchestrator.py

@@ -236,6 +236,48 @@ def fake_smoke(**_kw):
     assert "retrying" in log
 
 
+@pytest.mark.asyncio
+async def test_update_job_cancellation_records_terminal_status_and_releases_lock(
+    monkeypatch, tmp_path
+):
+    """Cancelling the job mid-await must not leave a stale RUNNING status."""
+    import asyncio
+
+    _isolate_update_files(monkeypatch, tmp_path)
+
+    async def fake_do_update(
+        *, print_output: bool, intent: update.UpdateIntent, output_callback=None
+    ):
+        return update.UpdateResult.UPDATED
+
+    monkeypatch.setattr(update, "do_update", fake_do_update)
+
+    started = asyncio.Event()
+
+    async def hanging_smoke_check(**_kw):
+        started.set()
+        await asyncio.sleep(60)
+        return (True, "unreachable")
+
+    monkeypatch.setattr(orchestrator, "_run_smoke_check_with_retry", hanging_smoke_check)
+
+    task = asyncio.create_task(
+        orchestrator.run_update_job(
+            print_output=False, intent=update.UpdateIntent.INSTALL, source="test"
+        )
+    )
+    await started.wait()
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task
+
+    assert not orchestrator.UPDATE_LOCK_FILE.exists()
+    status = orchestrator.read_update_status()
+    assert status is not None
+    assert status.state is orchestrator.UpdateJobState.FAILED
+    assert "cancelled" in (status.message or "").lower()
+
+
 @pytest.mark.asyncio
 async def test_run_update_prompt_routes_check_through_runner(monkeypatch):
     calls: list[update.UpdateIntent] = []