@@ -9,10 +9,6 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 FIXED
 
-- Async orchestrators wrapped with `functools.wraps` are now recognized even
-when an intermediate async wrapper decorates a synchronous function, including
-callable instances and partials. Cyclic wrapper chains fail instead of hanging
-worker dispatch.
 - 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
 
@@ -1,7 +1,22 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 
-"""Dispatch-local asyncio scheduling on top of the shared durable history engine."""
+"""Dispatch-local asyncio scheduling on top of the shared durable history engine.
+
+Private asyncio dependencies (verified against the supported Python versions):
+
+- ``asyncio._get_running_loop`` / ``asyncio._set_running_loop``: install this
+  loop as the running loop only while a dispatch drains ready callbacks, and
+  restore any host loop afterwards. ``Task.__await__`` uses the getter to
+  detect durable, foreign, or absent loops without raising.
+- ``asyncio.tasks._enter_task`` / ``asyncio.tasks._leave_task``: suspend and
+  restore the host's current task while draining, so asyncio does not see two
+  tasks running on one thread.
+- ``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.
+"""
 
 from __future__ import annotations
 
@@ -11,7 +26,7 @@
 import logging
 from collections import deque
 from collections.abc import Callable, Coroutine, Generator
-from datetime import datetime, timedelta
+from datetime import UTC, datetime, timedelta
 from fractions import Fraction
 from typing import Any, TypeVar, cast
 
@@ -137,7 +152,10 @@ def __init__(
 
     def time(self) -> float:
         # A fixed UTC epoch avoids local-time and platform timestamp differences.
-        return (self.ctx.current_utc_datetime - _EPOCH).total_seconds()
+        now = self.ctx.current_utc_datetime
+        if now.tzinfo is not None:
+            now = now.astimezone(UTC).replace(tzinfo=None)
+        return (now - _EPOCH).total_seconds()
 
     def get_debug(self) -> bool:
         return False
 
@@ -75,28 +75,40 @@ def from_json(json_str: str | bytes | bytearray, expected_type: type | None = No
 
 
 def is_async_callable(fn: Any) -> bool:
-    """Recognize async functions, wrapped functions, partials and callable objects."""
+    """Classify an orchestrator callable as async (``True``) or synchronous.
+
+    Each callable is checked directly before following ``functools.wraps``
+    metadata: coroutine functions are async and generator functions are
+    synchronous, even when they wrap a function of the other kind. Partials and
+    callable instances are resolved through ``func`` and ``__call__``. Only a
+    callable that is neither falls back to the function it wraps.
+    """
     # Keep nodes alive so temporary bound-method IDs cannot be reused.
     seen: dict[int, Any] = {}
+    wrapped_fallbacks: list[Any] = []
+    node: Any = fn
     while True:
-        identity = id(fn)
+        if node is None:
+            if not wrapped_fallbacks:
+                return False
+            node = wrapped_fallbacks.pop()
+        identity = id(node)
         if identity in seen:
             raise ValueError("wrapper loop when classifying async callable")
-        seen[identity] = fn
-        if inspect.iscoroutinefunction(fn):
+        seen[identity] = node
+        if inspect.iscoroutinefunction(node):
             return True
-        if hasattr(fn, "__wrapped__"):
-            fn = fn.__wrapped__
-            continue
-        if isinstance(fn, partial):
-            fn = fn.func
-            continue
-        if (inspect.isfunction(fn) or inspect.ismethod(fn)
-                or inspect.isbuiltin(fn) or inspect.ismethodwrapper(fn)):
-            return False
-        fn = getattr(fn, "__call__", None)
-        if fn is None:
+        if inspect.isgeneratorfunction(node) or inspect.isasyncgenfunction(node):
             return False
+        if hasattr(node, "__wrapped__"):
+            wrapped_fallbacks.append(node.__wrapped__)
+        if isinstance(node, partial):
+            node = node.func
+        elif (inspect.isfunction(node) or inspect.ismethod(node)
+                or inspect.isbuiltin(node) or inspect.ismethodwrapper(node)):
+            node = None
+        else:
+            node = getattr(node, "__call__", None)
 
 
 def _get_legacy_logging_warning_stacklevel() -> int:
 
@@ -4,9 +4,9 @@
 # See https://peps.python.org/pep-0563/
 from __future__ import annotations
 
+import asyncio
 import logging
 import math
-import asyncio
 from abc import ABC, abstractmethod
 from collections.abc import Callable, Coroutine, Generator, Sequence
 from dataclasses import dataclass
 
@@ -358,6 +358,7 @@ class _Registry:
 
     def __init__(self):
         self.orchestrators = {}
+        self._orchestrator_kinds: dict[str, tuple[task.Orchestrator[Any, Any], bool]] = {}
         self.activities = {}
         self.entities = {}
 
@@ -375,11 +376,20 @@ def add_named_orchestrator(self, name: str, fn: task.Orchestrator[TInput, TOutpu
         if name in self.orchestrators:
             raise ValueError(f"A '{name}' orchestrator already exists.")
 
+        # Classify once so wrapper problems surface at registration, not dispatch.
+        is_async = shared.is_async_callable(fn)
         self.orchestrators[name] = fn
+        self._orchestrator_kinds[name] = (fn, is_async)
 
     def get_orchestrator(self, name: str) -> task.Orchestrator[Any, Any] | None:
         return self.orchestrators.get(name)
 
+    def is_async_orchestrator(self, name: str, fn: task.Orchestrator[Any, Any]) -> bool:
+        kind = self._orchestrator_kinds.get(name)
+        if kind is not None and kind[0] is fn:
+            return kind[1]
+        return shared.is_async_callable(fn)
+
     def add_activity(self, fn: task.Activity[TInput, TOutput]) -> str:
         if fn is None:
             raise ValueError("An activity function argument is required.")
@@ -2745,7 +2755,7 @@ def process_event(
                         event.executionStarted.input.value, input_type)
 
                 # Layer 4 passes async orchestrators a cold context instead.
-                is_async = shared.is_async_callable(fn)
+                is_async = self._registry.is_async_orchestrator(event.executionStarted.name, fn)
                 result = fn(ctx, input)
 
                 if isinstance(result, CoroutineType) and not is_async:
@@ -2757,7 +2767,11 @@ def process_event(
                 if is_async and not isinstance(result, CoroutineType):
                     if isinstance(result, GeneratorType):
                         result.close()
-                    raise TypeError("An async orchestrator must return a coroutine.")
+                    raise TypeError(
+                        "An async orchestrator must return a coroutine. A synchronous wrapper "
+                        "decorated with functools.wraps(async_fn) is classified as async; declare "
+                        "the wrapper with 'async def', or do not copy the async function's metadata."
+                    )
                 if isinstance(result, (GeneratorType, CoroutineType)):
                     # Both protocols suspend on durable tasks and finish with StopIteration.
                     ctx.run(cast(Generator[task.Task[Any], Any, Any] | Coroutine[Any, Any, Any], result))
 
@@ -10,17 +10,21 @@
 import subprocess
 import sys
 from collections.abc import AsyncGenerator, Generator
-from datetime import datetime, timedelta
+from datetime import UTC, datetime, timedelta, timezone
 from functools import partial, update_wrapper, wraps
-from typing import Any
+from types import SimpleNamespace
+from typing import Any, cast
 
 import pytest
 
 from durabletask import entities, task, worker
 from durabletask.internal import helpers, shared
 from durabletask.internal import orchestrator_service_pb2 as pb
+from durabletask.internal.asyncio_loop import DurableEventLoop
 from durabletask.serialization import JsonDataConverter
 
+pytestmark = pytest.mark.filterwarnings("error::RuntimeWarning")
+
 
 INSTANCE_ID = "coroutine-test"
 NOW = datetime(2026, 1, 1)
@@ -211,14 +215,55 @@ def wrapper(*args: Any, **kwargs: Any) -> Generator[int, None, None]:
     assert inspect.getgeneratorstate(created[0]) == inspect.GEN_CLOSED
 
 
-def test_cyclic_async_wrapper_fails_instead_of_hanging() -> None:
+@pytest.mark.parametrize("shape", ["function", "partial", "callable"])
+def test_generator_wrapper_of_async_function_is_synchronous(shape: str) -> None:
+    async def async_orchestrator(ctx: task.OrchestrationContext, value: int) -> int:
+        return value
+
+    @wraps(async_orchestrator)
+    def generator(ctx: task.OrchestrationContext, value: int) -> Generator[task.Task[Any], Any, int]:
+        return (yield ctx.call_activity("work", input=value, return_type=int))
+
+    class GeneratorCallable:
+        def __call__(self, ctx: task.OrchestrationContext, value: int) -> Generator[task.Task[Any], Any, int]:
+            return (yield ctx.call_activity("work", input=value, return_type=int))
+
+    update_wrapper(GeneratorCallable.__call__, async_orchestrator)
+    variants: dict[str, Any] = {
+        "function": generator,
+        "partial": partial(generator),
+        "callable": GeneratorCallable(),
+    }
+    fn = variants[shape]
+    assert not shared.is_async_callable(fn)
+    actions = _execute(fn, [], _start()).actions
+    assert [a.scheduleTask.name for a in actions] == ["work"]
+
+
+def test_orchestrator_is_classified_once_at_registration(monkeypatch: pytest.MonkeyPatch) -> None:
+    async def orchestrator(ctx: task.OrchestrationContext, value: int) -> int:
+        return await ctx.call_activity("work", input=value, return_type=int)
+
+    registry = worker._Registry()  # pyright: ignore[reportPrivateUsage]
+    registry.add_named_orchestrator("test", orchestrator)
+    calls: list[Any] = []
+    original = shared.is_async_callable
+    monkeypatch.setattr(shared, "is_async_callable", lambda fn: calls.append(fn) or original(fn))
+    executor = worker._OrchestrationExecutor(  # pyright: ignore[reportPrivateUsage]
+        registry, logging.getLogger(__name__), JsonDataConverter())
+    old = _start() + [helpers.new_task_scheduled_event(1, "work")]
+    executor.execute(INSTANCE_ID, [], _start())
+    executor.execute(INSTANCE_ID, old, [helpers.new_task_completed_event(1, "4")])
+    assert calls == []
+
+
+def test_cyclic_async_wrapper_is_rejected_at_registration() -> None:
     def wrapper(ctx: task.OrchestrationContext, value: int) -> int:
         return value
 
     wrapper.__wrapped__ = wrapper  # type: ignore[attr-defined]
-    complete = _completion(_execute(wrapper, [], _start()))
-    assert complete.orchestrationStatus == pb.ORCHESTRATION_STATUS_FAILED
-    assert "wrapper loop" in complete.failureDetails.errorMessage
+    with pytest.raises(ValueError, match="wrapper loop"):
+        worker._Registry().add_named_orchestrator("test", wrapper)  # pyright: ignore[reportPrivateUsage]
 
 
 def _assert_mixed_wrapper_cycle_fails(shape: str) -> None:
@@ -235,21 +280,16 @@ def __call__(self, ctx: task.OrchestrationContext, value: int) -> int:
         wrapper.__wrapped__ = CallableWrapper()  # type: ignore[attr-defined]
         CallableWrapper.__call__.__wrapped__ = partial(wrapper)  # type: ignore[attr-defined]
 
-    # No input: dispatch must detect the cycle without relying on type discovery.
-    history = [
-        helpers.new_orchestrator_started_event(NOW),
-        helpers.new_execution_started_event("test", INSTANCE_ID),
-    ]
-    complete = _completion(_execute(wrapper, [], history))
-    assert complete.orchestrationStatus == pb.ORCHESTRATION_STATUS_FAILED
-    assert complete.failureDetails.errorType == "builtins.ValueError"
-    assert "wrapper loop" in complete.failureDetails.errorMessage
+    registry = worker._Registry()  # pyright: ignore[reportPrivateUsage]
+    with pytest.raises(ValueError, match="wrapper loop"):
+        registry.add_named_orchestrator("test", wrapper)
+    assert registry.get_orchestrator("test") is None
     with pytest.raises(ValueError, match="wrapper loop"):
         shared.is_async_callable(wrapper)
 
 
 @pytest.mark.parametrize("shape", ["partial", "callable-partial"])
-def test_mixed_wrapper_cycle_fails_within_bounded_worker_dispatch(shape: str) -> None:
+def test_mixed_wrapper_cycle_is_rejected_within_bounded_registration(shape: str) -> None:
     result = subprocess.run(
         [
             sys.executable, "-c",
@@ -555,3 +595,12 @@ async def orchestrator(ctx: task.OrchestrationContext, _: Any) -> AsyncGenerator
     complete = _completion(_execute(orchestrator, [], _start()))
     assert complete.orchestrationStatus == pb.ORCHESTRATION_STATUS_FAILED
     assert "Async generator orchestrators are not supported" in complete.failureDetails.errorMessage
+
+
+@pytest.mark.parametrize(("now", "offset"), [
+    (NOW, 0), (NOW.replace(tzinfo=UTC), 0), (NOW.replace(tzinfo=timezone(timedelta(hours=2))), 7200),
+])
+def test_loop_time_accepts_naive_and_aware_orchestration_clocks(now: datetime, offset: int) -> None:
+    ctx = cast(task.OrchestrationContext, SimpleNamespace(current_utc_datetime=now))
+    loop = DurableEventLoop(ctx, is_complete=lambda: False)
+    assert loop.time() == (NOW - datetime(1970, 1, 1)).total_seconds() - offset