@@ -16,10 +16,6 @@ unchanged.
 - Async dispatch cleanup no longer hangs when async-generator finalizers
 continually start successor generators; exceeding the cleanup budget is reported
 without changing the snapshotted response.
-- Coroutine task-group cancellation now schedules shared-Future callbacks
-deterministically across replays, including when a dispatch resumes on another
-worker using the same SDK and Python runtime. Previously recorded cancellation
-histories may replay differently; validate or drain them before upgrading.
 - Activity and sub-orchestration `retry_timeout` decisions now use replay-safe
 orchestration time, preventing retries from expiring solely because history is
 replayed later. Retry calculations also accept timezone-aware timestamps.
 
@@ -193,16 +193,20 @@ Create branches from ordered inputs. Ready work follows FIFO scheduling;
 history completions are delivered in history order, draining ready work after
 each completion. Task-group cancellation wakeups are ordered by local task
 creation, not set/object-hash iteration. Local tasks are dispatch resources,
-not new durable instances.
+not new durable instances. Create them with `asyncio.create_task` or a task
+group; do not construct `asyncio.Task` directly, because such tasks are not
+tracked by the dispatch and are not cancelled or cleaned up with it.
 
 `loop.time()` uses seconds from a fixed UTC epoch and the current orchestration
 clock, never machine monotonic time. `loop.call_at` and `call_later` schedule
 durable timers for future finite deadlines. Timer conversion rounds up when
 necessary so a durable timer does not precede its floating-point deadline.
 Core/Functions long timers reuse the existing chunking; Azure Managed retains
 its native long timers. Past deadlines are ready callbacks. `sleep(0)` yields
-to ready coroutines without a durable timer. Clock advancement and timers
-require history events, not elapsed time in the worker.
+to ready coroutines without a durable timer. Delays below the resolution of
+`loop.time()` (about 238 nanoseconds at current dates) are effectively zero.
+Clock advancement and timers require history events, not elapsed time in the
+worker.
 
 > [!WARNING]
 > This is not a general-purpose asyncio event loop. External network/storage
 
@@ -12,11 +12,6 @@ FIXED
 - With the corresponding core SDK update, async dispatch cleanup no longer
 hangs when async-generator finalizers continually start successor generators.
 Exceeding the cleanup budget is reported without changing the snapshotted response.
-- With the corresponding core SDK update, coroutine task-group cancellation
-schedules shared-Future callbacks deterministically when replayed on another
-worker using the same SDK and Python runtime. See the
-[core upgrade guidance](../CHANGELOG.md#unreleased) for existing cancellation
-histories.
 - With the corresponding core SDK update, activity and sub-orchestration
 `retry_timeout` decisions use replay-safe orchestration time rather than
 wall-clock time. See the [core upgrade guidance](../CHANGELOG.md#unreleased)
 
@@ -15,15 +15,22 @@
 - ``asyncio.Handle._run``: run a ready callback with asyncio's own context and
   exception-handler semantics.
 - ``asyncio.Task._log_traceback``: report unobserved local-task failures during
-  dispatch cleanup without marking them as retrieved.
+  dispatch cleanup without marking them as retrieved, and keep such tasks
+  tracked until then.
+- ``__self__`` of Task step/wakeup callbacks (including the C implementation's
+  step wrapper and bound ``task_wakeup``): identify which local task a
+  callback resumes, so task-group cancellation wakeups run in task-creation
+  order.
+- ``AbstractEventLoop._timer_handle_cancelled``: the hook ``TimerHandle.cancel``
+  calls on its loop, used to withdraw the durable timer observer.
 """
 
 from __future__ import annotations
 
 import asyncio
 import contextvars
-import math
 import logging
+import math
 import sys
 from collections import deque
 from collections.abc import Callable, Coroutine, Generator
@@ -72,8 +79,10 @@ def __init__(
         super().__init__(coro, loop=loop, name=name, context=context)
 
     def __hash__(self) -> int:
-        # TaskGroup traverses a set before cancellation schedules shared-Future
-        # callbacks. Stabilize that traversal, not just the resulting wakeups.
+        # Load-bearing for replay determinism: TaskGroup keeps its children in a
+        # set and iterates it to cancel them. Hashing by creation sequence makes
+        # that traversal, and the cancellation wakeups it schedules, follow task
+        # creation order instead of memory addresses that differ across workers.
         return self._sequence
 
     def __await__(self) -> Generator[Any, None, T]:
@@ -162,12 +171,15 @@ def __init__(
         self._cleanup_failure: BaseException | None = None
         self._root: asyncio.Task[Any] | None = None
 
-    def time(self) -> float:
-        # A fixed UTC epoch avoids local-time and platform timestamp differences.
+    def _now(self) -> datetime:
         now = self.ctx.current_utc_datetime
         if now.tzinfo is not None:
             now = now.astimezone(UTC).replace(tzinfo=None)
-        return (now - _EPOCH).total_seconds()
+        return now
+
+    def time(self) -> float:
+        # A fixed UTC epoch avoids local-time and platform timestamp differences.
+        return (self._now() - _EPOCH).total_seconds()
 
     def get_debug(self) -> bool:
         return False
@@ -216,7 +228,8 @@ def call_soon(
             # TaskGroup cancels a set of tasks. Do not let object hashes
             # determine the order in which their finally blocks execute.
             owner = getattr(callback, "__self__", None)
-            index = self._tasks[self.cancelling_task]
+            index = self._tasks.get(
+                self.cancelling_task, getattr(self.cancelling_task, "_sequence", self._task_sequence))
             if isinstance(owner, asyncio.Task):
                 index = self._tasks.get(cast(asyncio.Task[Any], owner), index)
             self._cancel_ready.append((index, len(self._cancel_ready), handle))
@@ -242,7 +255,7 @@ def call_at(
         # Exact rational ceiling: float round-trips can emit a deadline that
         # precedes the requested one by a fraction of a microsecond.
         deadline_us = math.ceil(Fraction(when) * 1_000_000)
-        now_us = (self.ctx.current_utc_datetime - _EPOCH) // _MICROSECOND
+        now_us = (self._now() - _EPOCH) // _MICROSECOND
         if when <= self.time() or deadline_us <= now_us:
             self._ready.append(handle)
         else:
@@ -284,7 +297,10 @@ async def wait_durable(self, durable: task.Task[T]) -> T:
             entry[1].remove(future)
             if not entry[1]:
                 self._waits.pop(id(durable), None)
-                self._observers.pop(id(durable)).detach()
+                # Dispatch close may already have detached and cleared observers.
+                observer = self._observers.pop(id(durable), None)
+                if observer is not None:
+                    observer.detach()
 
     def _complete_wait(self, durable: task.Task[Any]) -> None:
         entry = self._waits.get(id(durable))
@@ -473,24 +489,43 @@ def close(self) -> None:
             self._tasks.clear()
             self._asyncgens.clear()
 
-    def run_in_executor(self, executor: Any, func: Any, *args: Any) -> asyncio.Future[Any]:
-        raise RuntimeError("Threads/executors are unsupported in orchestrators; use an activity.")
-
-    def call_soon_threadsafe(self, callback: Any, *args: Any, context: Any = None) -> asyncio.Handle:
-        raise RuntimeError("Cross-thread scheduling is unsupported in orchestrators; use an activity.")
-
-    async def _unsupported_io(self, *args: Any, **kwargs: Any) -> Any:
-        raise RuntimeError("External I/O is unsupported in orchestrators; move it to an ordinary activity.")
-
-    create_connection = _unsupported_io
-    create_server = _unsupported_io
-    create_datagram_endpoint = _unsupported_io
-    connect_read_pipe = _unsupported_io
-    connect_write_pipe = _unsupported_io
-    getaddrinfo = _unsupported_io
-    getnameinfo = _unsupported_io
-    sock_connect = _unsupported_io
-    sock_recv = _unsupported_io
-    sock_sendall = _unsupported_io
-    subprocess_exec = _unsupported_io
-    subprocess_shell = _unsupported_io
+
+_IO_HINT = "External I/O is unsupported in orchestrators; move it to an ordinary activity."
+_THREAD_HINT = "Threads/executors are unsupported in orchestrators; use an activity."
+_LOOP_HINT = "The worker owns the durable loop's lifecycle and configuration."
+
+# Every asyncio loop API this loop does not implement fails with one actionable
+# error instead of AbstractEventLoop's bare NotImplementedError.
+_UNSUPPORTED_LOOP_APIS: dict[str, str] = {
+    **dict.fromkeys((
+        "create_connection", "create_server", "create_datagram_endpoint",
+        "create_unix_connection", "create_unix_server", "connect_accepted_socket",
+        "connect_read_pipe", "connect_write_pipe", "start_tls", "sendfile",
+        "getaddrinfo", "getnameinfo", "sock_connect", "sock_accept", "sock_recv",
+        "sock_recv_into", "sock_recvfrom", "sock_recvfrom_into", "sock_sendall",
+        "sock_sendto", "sock_sendfile", "subprocess_exec", "subprocess_shell",
+        "add_reader", "remove_reader", "add_writer", "remove_writer",
+        "add_signal_handler", "remove_signal_handler",
+    ), _IO_HINT),
+    **dict.fromkeys((
+        "run_in_executor", "set_default_executor", "shutdown_default_executor",
+        "call_soon_threadsafe",
+    ), _THREAD_HINT),
+    **dict.fromkeys((
+        "run_forever", "run_until_complete", "stop", "set_task_factory",
+        "set_exception_handler",
+    ), _LOOP_HINT),
+}
+
+
+def _unsupported_loop_api(name: str, hint: str) -> Callable[..., Any]:
+    def unsupported(self: DurableEventLoop, *args: Any, **kwargs: Any) -> Any:
+        raise RuntimeError(f"loop.{name}() is not supported in durable orchestrators. {hint}")
+
+    unsupported.__name__ = unsupported.__qualname__ = name
+    return unsupported
+
+
+for _name, _hint in _UNSUPPORTED_LOOP_APIS.items():
+    if _name not in vars(DurableEventLoop):
+        setattr(DurableEventLoop, _name, _unsupported_loop_api(_name, _hint))
@@ -13,17 +13,19 @@
 from contextlib import asynccontextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass
-from datetime import timedelta
+from datetime import datetime, timedelta
 from decimal import ROUND_CEILING, Decimal, localcontext
 from functools import partial
-from typing import Any
+from types import SimpleNamespace
+from typing import Any, cast
 from weakref import ReferenceType, ref
 
 import pytest
 
 from durabletask import entities, task
 from durabletask.internal import helpers
 from durabletask.internal import orchestrator_service_pb2 as pb
+from durabletask.internal.asyncio_loop import _UNSUPPORTED_LOOP_APIS, DurableEventLoop  # pyright: ignore[reportPrivateUsage]
 from tests.durabletask.test_coroutine_orchestrators import (
     NOW,
     _completion,  # pyright: ignore[reportPrivateUsage]
@@ -492,7 +494,6 @@ async def orchestrator(ctx: task.AsyncOrchestrationContext, _: Any) -> None:
     actions = _execute(orchestrator, [], _start()).actions
     assert len(actions) == 1
     deadline = actions[0].createTimer.fireAt.ToDatetime()
-    from datetime import datetime
     assert (deadline - datetime(1970, 1, 1)).total_seconds() >= observed[0]
 
 
@@ -630,6 +631,30 @@ async def resource():
         assert "cleanup failed" in caplog.text
 
 
+@pytest.mark.parametrize("name", sorted(_UNSUPPORTED_LOOP_APIS))
+def test_every_unsupported_loop_api_fails_actionably(name: str) -> None:
+    ctx = cast(task.OrchestrationContext, SimpleNamespace(current_utc_datetime=NOW))
+    loop = DurableEventLoop(ctx, is_complete=lambda: False)
+    with pytest.raises(RuntimeError, match=rf"loop\.{name}\(\) is not supported") as error:
+        getattr(loop, name)()
+    assert str(error.value).endswith(_UNSUPPORTED_LOOP_APIS[name])
+
+
+def test_untracked_task_finalized_after_dispatch_close_is_quiet(monkeypatch: pytest.MonkeyPatch) -> None:
+    unraisable: list[Any] = []
+    monkeypatch.setattr(sys, "unraisablehook", unraisable.append)
+    untracked: list[asyncio.Task[Any]] = []
+
+    async def orchestrator(ctx: task.OrchestrationContext, _: Any) -> None:
+        untracked.append(asyncio.Task(ctx.call_activity("background").wait()))
+        await ctx.call_activity("work")
+
+    _execute(orchestrator, [], _start())
+    untracked.clear()
+    gc.collect()
+    assert not [hook for hook in unraisable if isinstance(hook.exc_value, KeyError)]
+
+
 def test_task_group_cancellation_durable_cleanup_has_stable_action_order() -> None:
     async def orchestrator(ctx: task.AsyncOrchestrationContext, _: Any) -> None:
         async def branch(index: int) -> None: