fix(sdk/python): run destructor cleanup synchronously when no loop is running (#620 follow-up)

[AbirAbbas]

Follow-up to #899, which merged before this review landed. Two things from that review: one verified regression and one gap.

1. Regression: Agent.__del__ cleanup stopped running

#899 replaced the bare asyncio.run(self._cleanup_async_resources()) in Agent.__del__ with fire_and_forget(...).

fire_and_forget() has two branches. The running-loop branch was the point of the change and is genuinely a fix — pre-#899 the destructor called asyncio.run() on the loop thread, which raised RuntimeError and got swallowed by the surrounding except Exception: pass, so cleanup never happened. But the no-running-loop branch spawns a daemon thread that calls asyncio.run(coro). That's the common destructor case (GC / interpreter exit), and a daemon thread is killed at interpreter exit before it does any work.

Side-by-side probe (same agent, _cleanup_async_resources instrumented, process exits right after the destructor runs):

	no running loop	loop running
pre-#899 (asyncio.run)	cleanup completed	RuntimeError, swallowed — cleanup skipped
#899 (fire_and_forget)	thread killed at exit — cleanup skipped	cleanup completed
this PR (dispatch on loop)	cleanup completed	cleanup completed

So AsyncExecutionManager.stop(), the background-task gather, and the notification-dispatcher shutdown were all being silently dropped in the case that fires most often.

Fix: dispatch on loop presence inside the existing try/except — synchronous asyncio.run() when no loop is running (so destructor-at-exit cleanup actually completes), fire_and_forget() only when a loop is already running (where asyncio.run() would raise).

2. Gap: fire_and_forget's running-loop branch was un-retained and unobserved

loop.create_task(coro) with no reference kept. asyncio only holds a weak reference to a task, so it could be collected mid-flight and silently never complete; and because nobody retrieved the result, a failing task printed Task exception was never retrieved on collection — the exact noise the thread branch of #899 fixed for the no-loop case.

Fix: retain the task in a module-level _BACKGROUND_TASKS set and attach a done callback that discards the reference, ignores cancellation, and logs the exception at debug with the same "fire_and_forget background task failed" message the thread branch uses.

Validation Contract

	Behavior	Test
C1	Destructing an Agent when no event loop is running executes _cleanup_async_resources to completion synchronously, before __del__ returns.	tests/test_agent_core.py::test_del_runs_cleanup_to_completion_when_no_loop_is_running
C2	Destructing an Agent while a loop is running schedules cleanup on that loop without blocking it; the cleanup runs once the loop yields.	tests/test_agent_core.py::test_del_schedules_cleanup_on_the_running_loop_without_blocking
C3	A coroutine passed to fire_and_forget inside a running loop that raises does not produce Task exception was never retrieved noise; the failure is logged at debug level.	tests/test_run_async.py::test_fire_and_forget_running_loop_failure_is_logged_not_noisy
C4	The scheduled task is referenced by the module while pending (not garbage-collectable) and the reference is released after completion.	tests/test_run_async.py::test_fire_and_forget_running_loop_task_is_retained_until_done

C1, C3 and C4 fail against the pre-fix source on this branch (verified by reverting just the two source files and re-running). C2 passes both before and after — it is a regression guard for the behavior #899 correctly fixed, which this PR must not undo.

Gates

• ruff check . (CI-pinned ruff 0.15.22) — All checks passed
• ./scripts/run_pytest.sh (full suite, what CI runs) — 1885 passed, 4 skipped, 36 deselected

Refs #620. Follow-up to #899.

🤖 Generated with Claude Code

[github-actions]

Performance

SDK	Memory	Δ	Latency	Δ	Tests	Status
Python	9.0 KB	-	0.32 µs	-9%	✓	✓

✓ No regressions detected

[github-actions]

📊 Coverage gate

Thresholds from .coverage-gate.toml: per-surface ≥ 84%, aggregate ≥ 85%, max per-surface regression ≤ 1.0 pp, max aggregate regression ≤ 0.50 pp.

Surface	Current	Baseline	Δ
control-plane	87.10%	87.40%	↓ -0.30 pp	🟡
sdk-go	92.70%	92.00%	↑ +0.70 pp	🟢
sdk-python	93.82%	93.73%	↑ +0.09 pp	🟢
sdk-typescript	91.17%	90.42%	↑ +0.75 pp	🟢
web-ui	84.75%	84.79%	↓ -0.04 pp	🟡
aggregate	85.62%	85.75%	↓ -0.13 pp	🟡

✅ Gate passed

No surface regressed past the allowed threshold and the aggregate stayed above the floor.

[github-actions]

📐 Patch coverage gate

Threshold: 80% on lines this PR touches vs origin/main (from .coverage-gate.toml:thresholds.min_patch).

Surface	Touched lines	Patch coverage	Status
control-plane	0	—	➖ no changes
sdk-go	0	—	➖ no changes
sdk-python	0	—	➖ no changes
sdk-typescript	0	—	➖ no changes
web-ui	0	—	➖ no changes

✅ Patch gate passed

Every surface whose lines were touched by this PR has patch coverage at or above the threshold.