[nicoloboschi]

The bug this found

hindsight-embed's probe_get() ran asyncio.run() on the caller's thread. asyncio.run doesn't just close the loop it creates — it leaves the thread with no current event loop. Loop state is per-thread, so a library helper doing that sabotages any sync caller that probes between its own calls: hindsight-client._run_async then finds no loop, builds a fresh one, and issues the next request through an aiohttp session still bound to the old one.

Same script, two builds:

PyPI 0.9.2 (works)                 working tree 0.10.0 (fails)
loop=5106485712  _ensure_started   no loop
loop=5106485712  delete_bank       loop=13295694816
loop=5106485712  create_bank       loop=13295696304   <- different loop
RETAIN OK                          RuntimeError: Timeout context manager
                                   should be used inside a task

That is exactly the Hermes memory plugin in local_embedded mode, where a daemon health probe sits between two client calls — embedded memory is broken on main today. Introduced by #4318 (httpx -> aiohttp), after the last release, which is why it reproduces against working-tree wheels but not PyPI.

Fix: the probe always runs on its own loop in a helper thread, never the caller's. That deletes the existing special case rather than adding one, and fixes every caller at the shared function.

The regression test pins the invariant (the caller's loop survives a probe). I verified it actually catches the bug by reverting the fix — it fails with the exact no current event loop error.

Why it went unnoticed, and the gate change that surfaced it

test-hermes-compat.sh has never had an LLM key in CI, so the retain path it guards had literally never executed. And since the provider left the Hermes tree, the script was testing Hermes' bundled copy — bundled wins on a name collision, and steps 4-6 never ran a line of plugin code.

• Step 3 (new) — removes the bundled provider, installs this checkout's plugin, runs hermes plugins validate (the catalog admission gate, so a change that would be rejected upstream fails here instead of in their review queue), and asserts which copy loaded. Also means the script keeps working the day Nous drops the bundle.
• Step 7 (new) — drives the MemoryProvider contract agent_init uses: is_available -> initialize -> sync_turn -> prefetch -> recall_status -> hindsight_recall -> on_session_end -> shutdown. Polls for extraction rather than sleeping, so a slow runner doesn't flake.
• Step 5 — additionally asserts all four Hindsight distributions are still the locally built wheels. The plugin self-installs hindsight-all from PyPI when local_embedded has no runtime (right for a user, fatal here): it would swap the branch under review for a published release and leave the gate passing on code nobody changed.

CI: runs on integrations-hermes changes (a plugin edit triggered nothing before), passes an LLM key so the round-trips execute, timeout 45 -> 60.

Verification

Full script against hermes-agent@main, all 7 steps:

[3/7] validation passed; provider resolves to the external plugin
[5/7] all four Hindsight distributions are the locally built wheels
[6/7] daemon started, retained a memory, recalled (RecallResponse)
[7/7] sync_turn -> prefetch injected the retained memory -> recall_status -> 1 memory
=== PASS: hermes-agent@main is compatible with this Hindsight ===

Plus 226 hindsight-embed tests, lint clean.

Scope note

The branch started as a CI change and now carries the hindsight-embed fix too. I kept them together because the fix is what makes the gate pass — splitting means landing a knowingly-red CI change. Happy to split if preferred.

Follow-up, deliberately not fixed here

hindsight-client._run_async relies on thread-global loop state while holding a long-lived aiohttp session. Any third-party asyncio.run breaks it the same way; the durable fix is the client owning its own loop. Worth its own issue.