Make TinyMemory engine resolution async

crates/tinymemory-tools/src/lifecycle/turn.rs

@@ -56,13 +56,14 @@ pub trait Clock: Send + Sync {
 }
 
 /// Resolves the configured engine and identity to their lifecycle instance.
+#[async_trait]
 pub trait EngineResolver: Send + Sync {
     /// Returns the configured memory instance for this host hook.
     ///
     /// # Errors
     ///
     /// Returns the host's engine or identity resolution failure.
-    fn resolve(&self) -> tinymemory_api::Result<AgentMemory>;
+    async fn resolve(&self) -> tinymemory_api::Result<AgentMemory>;
 }
 
 /// Receives background jobs returned by a successful post-turn log.
@@ -307,7 +308,7 @@ impl TurnHooks {
         let work_clock = clock.clone();
         let model = self.date_hint_model.clone();
         let operation = async move {
-            let mut memory = resolver.resolve().ok()?;
+            let mut memory = resolver.resolve().await.ok()?;
             if deadline.is_some_and(|deadline| work_clock.now() >= deadline) {
                 return None;
             }
@@ -427,7 +428,7 @@ impl TurnHooks {
         if !logging {
             return;
         }
-        let Ok(memory) = self.resolver.resolve() else {
+        let Ok(memory) = self.resolver.resolve().await else {
             return;
         };
         let Ok(report) = memory.post_turn(turn).await else {
@@ -483,7 +484,7 @@ impl TurnHooks {
         let resolver = self.resolver.clone();
         let clock = self.clock.clone();
         let operation = async move {
-            let memory = resolver.resolve().ok()?;
+            let memory = resolver.resolve().await.ok()?;
             if deadline.is_some_and(|deadline| clock.now() >= deadline) {
                 return None;
             }

crates/tinymemory-tools/src/lifecycle/turn_runtime_tests.rs

@@ -138,8 +138,27 @@ struct StaticResolver {
     advance: Duration,
 }
 
+struct DeferredResolver {
+    memory: AgentMemory,
+    release: Mutex<Option<oneshot::Receiver<()>>>,
+    calls: AtomicUsize,
+}
+
+#[async_trait]
+impl EngineResolver for DeferredResolver {
+    async fn resolve(&self) -> Result<AgentMemory> {
+        self.calls.fetch_add(1, Ordering::SeqCst);
+        let release = self.release.lock().unwrap().take();
+        if let Some(release) = release {
+            let _ = release.await;
+        }
+        Ok(self.memory.clone())
+    }
+}
+
+#[async_trait]
 impl EngineResolver for StaticResolver {
-    fn resolve(&self) -> Result<AgentMemory> {
+    async fn resolve(&self) -> Result<AgentMemory> {
         self.calls.fetch_add(1, Ordering::SeqCst);
         self.clock.advance_by(self.advance);
         if self.fail {
@@ -296,6 +315,41 @@ fn fixture_with_memory_and_advance(
     }
 }
 
+#[tokio::test]
+async fn pre_turn_awaits_async_engine_resolution() {
+    let engine = Arc::new(ReferenceEngine::new());
+    let (release, wait) = oneshot::channel();
+    let resolver = Arc::new(DeferredResolver {
+        memory: memory(engine),
+        release: Mutex::new(Some(wait)),
+        calls: AtomicUsize::new(0),
+    });
+    let clock = FakeClock::at(Duration::ZERO);
+    let citations = Arc::new(RecordingCitations::default());
+    let hooks = TurnHooks::new(
+        resolver.clone(),
+        Arc::new(clock.clone()),
+        None,
+        Arc::new(RecordingJobs::default()),
+        citations.clone(),
+    );
+    let mut work = Box::pin(hooks.pre_turn(
+        PreTurn::new("thread", 0, "remember this"),
+        options(true, true),
+    ));
+
+    poll_fn(|cx| match work.as_mut().poll(cx) {
+        Poll::Pending => Poll::Ready(()),
+        Poll::Ready(_) => panic!("pre-turn completed before async engine resolution"),
+    })
+    .await;
+    assert_eq!(resolver.calls.load(Ordering::SeqCst), 1);
+    release.send(()).unwrap();
+
+    let _ = work.await;
+    assert_eq!(citations.calls.load(Ordering::SeqCst), 0);
+}
+
 fn options(logging: bool, recall: bool) -> PreTurnOptions {
     PreTurnOptions {
         logging,