@@ -9,6 +9,10 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 FIXED
 
+- 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.
 
@@ -261,6 +261,12 @@ automatic recording or interception of arbitrary await expressions.
 `is_replaying` is not a substitute for recording results. Activities remain
 at-least-once work: side effects require appropriate idempotency/deduplication.
 
+Successive orchestration dispatches and their activities can run on different
+workers. Replay reconstructs local tasks and futures from ordered durable
+history; it does not rely on task identities or memory retained by a previous
+worker. Activity completion order is the order recorded in history, not worker
+placement.
+
 Framework adapters can compose supported durable operations using async
 helpers. Adapters remain responsible for registering ordinary model/tool
 activities, encoding/decoding framework payloads, and supplying replay-stable
@@ -279,7 +285,8 @@ construction order is not execution order.
 
 Supporting several Python versions does not guarantee recorded-history
 portability between them. Pin the runtime and dependencies for active
-instances and validate histories before upgrades. In particular, Python 3.11
+instances and validate histories before upgrades. All workers processing an
+instance must use that pinned environment. In particular, Python 3.11
 and 3.12+ schedule coroutine operands of `asyncio.wait_for()` differently, which
 can change durable action order inside concurrent branches. The async context
 does not normalize arbitrary standard-library scheduling.
 
@@ -9,6 +9,11 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 FIXED
 
+- 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)
 
@@ -35,6 +35,19 @@ def detach(self) -> None:
 
 
 class _DurableAsyncTask(asyncio.Task[T]):
+    def __init__(
+        self, coro: Coroutine[Any, Any, T] | Generator[Any, None, T], *,
+        sequence: int, loop: DurableEventLoop, name: str | None,
+        context: contextvars.Context | None,
+    ) -> None:
+        self._sequence = sequence
+        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.
+        return self._sequence
+
     def __await__(self) -> Generator[Any, None, T]:
         try:
             return (yield from super().__await__())
@@ -147,9 +160,10 @@ def create_task(
         if kwargs:
             coro.close()
             raise TypeError("Custom/eager task execution is not supported in durable orchestrators.")
-        future = _DurableAsyncTask(coro, loop=self, name=name, context=context)
-        self._tasks[future] = self._task_sequence
+        sequence = self._task_sequence
         self._task_sequence += 1
+        future = _DurableAsyncTask(coro, sequence=sequence, loop=self, name=name, context=context)
+        self._tasks[future] = sequence
         future.add_done_callback(self.retire_task)
         return future
 
 
@@ -6,9 +6,13 @@
 import asyncio
 import gc
 import json
+import os
+import subprocess
+import sys
 from contextvars import ContextVar
 from dataclasses import dataclass
 from datetime import timedelta
+from functools import partial
 from typing import Any
 from weakref import ReferenceType, ref
 
@@ -463,6 +467,114 @@ async def branch(index: int) -> None:
         assert _execute(orchestrator, [], old).actions == expected
 
 
+async def _shared_future_cancellation_orchestrator(
+    ctx: task.OrchestrationContext, _: Any, *, direct_future: bool, gather_wait: bool,
+) -> str:
+    loop = asyncio.get_running_loop()
+    futures: list[asyncio.Future[None]] = [
+        asyncio.Future[None]() if direct_future else loop.create_future() for _ in range(2)]
+
+    def on_cancelled(index: int, future: asyncio.Future[None]) -> None:
+        assert future.cancelled()
+        ctx.call_activity(f"cancelled-{index}")
+
+    for index, future in enumerate(futures):
+        future.add_done_callback(partial(on_cancelled, index))
+
+    async def wait(future: asyncio.Future[None]) -> None:
+        if gather_wait:
+            await asyncio.gather(future)
+        else:
+            await future
+
+    async def fail() -> None:
+        await asyncio.sleep(0)
+        raise ValueError("cancel siblings")
+
+    try:
+        async with asyncio.TaskGroup() as group:
+            for future in futures * 2:
+                group.create_task(wait(future))
+            group.create_task(fail())
+    except* ValueError:
+        pass
+    return await ctx.call_activity("join", return_type=str)
+
+
+@pytest.mark.parametrize("direct_future", [False, True])
+@pytest.mark.parametrize("gather_wait", [False, True])
+def test_shared_future_cancellation_callbacks_replay_on_fresh_executors(
+    direct_future: bool, gather_wait: bool,
+) -> None:
+    orchestrator = partial(
+        _shared_future_cancellation_orchestrator, direct_future=direct_future, gather_wait=gather_wait)
+    start = _start()
+    initial = _execute(orchestrator, [], start)
+    assert sorted(a.scheduleTask.name for a in initial.actions[:-1]) == ["cancelled-0", "cancelled-1"]
+    assert initial.actions[-1].scheduleTask.name == "join"
+    recorded = start + [
+        helpers.new_task_scheduled_event(action.id, action.scheduleTask.name)
+        for action in initial.actions
+    ]
+    # Activity workers may complete in any order. Each dispatch reconstructs
+    # all local tasks and futures from history, as on a different worker.
+    completed = [
+        helpers.new_task_completed_event(initial.actions[1].id, "null"),
+        helpers.new_task_completed_event(initial.actions[0].id, "null"),
+    ]
+    for _ in range(30):
+        assert _execute(orchestrator, [], start).actions == initial.actions
+        assert _execute(orchestrator, recorded, completed).actions == []
+        complete = _completion(_execute(
+            orchestrator, recorded + completed,
+            [helpers.new_task_completed_event(initial.actions[-1].id, '"joined"')]))
+        assert complete.orchestrationStatus == pb.ORCHESTRATION_STATUS_COMPLETED, complete.failureDetails
+        assert json.loads(complete.result.value) == "joined"
+
+
+def test_shared_future_cancellation_history_replays_in_other_worker_processes() -> None:
+    orchestrator = partial(
+        _shared_future_cancellation_orchestrator, direct_future=True, gather_wait=False)
+    start = _start()
+    initial = _execute(orchestrator, [], start)
+    history = start + [
+        helpers.new_task_scheduled_event(action.id, action.scheduleTask.name)
+        for action in initial.actions
+    ]
+    history += [
+        helpers.new_task_completed_event(initial.actions[1].id, "null"),
+        helpers.new_task_completed_event(initial.actions[0].id, "null"),
+    ]
+    payload = json.dumps({
+        "initial": [action.SerializeToString().hex() for action in initial.actions],
+        "history": [event.SerializeToString().hex() for event in history],
+        "join_id": initial.actions[-1].id,
+    })
+    code = """
+import json
+import sys
+from functools import partial
+from durabletask.internal import helpers, orchestrator_service_pb2 as pb
+from tests.durabletask.test_asyncio_orchestrators import _shared_future_cancellation_orchestrator
+from tests.durabletask.test_coroutine_orchestrators import _completion, _execute, _start
+
+data = json.load(sys.stdin)
+orchestrator = partial(_shared_future_cancellation_orchestrator, direct_future=True, gather_wait=False)
+initial = _execute(orchestrator, [], _start())
+assert [action.SerializeToString().hex() for action in initial.actions] == data["initial"]
+history = [pb.HistoryEvent.FromString(bytes.fromhex(event)) for event in data["history"]]
+result = _completion(_execute(
+    orchestrator, history, [helpers.new_task_completed_event(data["join_id"], '"joined"')]))
+assert result.orchestrationStatus == pb.ORCHESTRATION_STATUS_COMPLETED, result.failureDetails
+assert json.loads(result.result.value) == "joined"
+"""
+    for seed in ("0", "999"):
+        process = subprocess.run(
+            [sys.executable, "-c", code], input=payload, capture_output=True, text=True,
+            env={**os.environ, "PYTHONHASHSEED": seed}, timeout=30)
+        assert process.returncode == 0, process.stdout + process.stderr
+
+
 def test_cancelling_last_loop_timer_cannot_hide_foreign_wait() -> None:
     async def orchestrator(ctx: task.OrchestrationContext, _: Any) -> None:
         handle = asyncio.get_running_loop().call_later(1, lambda: None)