[Lushiyao5]

Motivation & Context

TodoProvider serializes its read-modify-write todo operations with a lock owned by the provider instance and keyed only by session. Two agents that each use their own provider over one shared TodoStore take different locks: both load the same state and next_id, and the last save silently drops the other write while both tool calls report success for the same item id. A session reused across asyncio.run boundaries can also raise from a lock bound to the previous event loop.

Description & Review Guide

• What are the major changes? The lock is now looked up from a process-wide registry keyed by (id(store), running loop, id(session)) and held weakly, so providers sharing a store serialize with each other, unrelated sessions of one store still mutate concurrently, and a session is safe across event loops. Values live only while a mutation holds or awaits the lock. TodoProvider no longer owns a WeakKeyDictionary of locks.
• What is the impact of these changes? Concurrent mutations over one shared store now behave like mutations from a single provider (distinct ids, no dropped items). Coordination remains process-local; other processes and other stores over the same backing storage are not serialized.
• What do you want reviewers to focus on? The lock key (ids rather than objects, so an unhashable store still works and the map cannot keep objects alive) and the per-loop scoping, which mirrors the file-access layer's existing per-loop lock keys.

Related Issue

Fixes #9868

[Copilot]

🟡 Changes recommended

Outstanding concurrency defects allow shared-file mutations to bypass locking or outlive it after cancellation, causing duplicate IDs and lost updates.

3 open issues

• Lock by shared TodoFileStore state identity · New
• Coordinate mutations across event loops · New
• Hold the mutation lock until cancelled writes finish · New

What changed in this PR

This PR addresses #9868 by moving Python todo mutation locks from individual providers to a shared registry, coordinating providers that use the same store and session object within an event loop.

Changes:

• Keys locks by store identity, running event loop, and session identity.
• Holds locks weakly so unused entries can be released.
• Adds regression coverage for shared-store mutations, lock cleanup, and event-loop isolation.

File	Description
python/​packages/​core/​tests/​core/​test_harness_todo.py	Tests shared-provider serialization, lock lifetime, and store/loop scoping.
python/​packages/​core/​agent_framework/​_harness/​_todo.py	Replaces provider-owned locks with a shared weak-value lock registry.

_{Review effort: Balanced}

[Lushiyao5]

@microsoft-github-policy-service agree

[Lushiyao5]

Addressed the Copilot review comments (two fixed, one remains a documented limitation):

1. Lock by shared store state identity — fixed. Lock keys now come from a new TodoStore._mutation_identity(session, source_id) hook instead of id(store)/id(session). The default identity is the session object (in-memory stores keep state on the session itself); TodoFileStore overrides it with the resolved state file path, so two sessions with the same session ID (and owner scope) — or two store instances over the same directory — now share one lock. As a side effect, two TodoSessionStore instances over one session object also share a lock, which is correct since both write session.state. Covered by new tests test_todo_mutation_lock_shares_one_file_identity_for_equivalent_sessions and test_todo_providers_serialize_equivalent_sessions_over_one_file (all four new/updated tests fail without the fix).
2. Hold the mutation lock until cancelled writes finish — fixed. Saves inside the locked section now run through _save_state_holding_lock, which shields the save: on cancellation the lock is held until the in-flight write completes, then the cancellation is re-raised. Covered by test_todo_mutation_keeps_lock_until_cancelled_write_finishes.
3. Coordinate mutations across event loops — not addressed; the lock remains per-loop and process-local by design (documented in the _todo_mutation_lock docstring). Cross-loop coordination would need a blocking primitive across loops, which changes the concurrency contract more than this fix intends; happy to follow the maintainers' direction here.

All 25 tests in test_harness_todo.py pass (40 passed together with test_harness_file_memory.py).