tests: fast host suites

The timing rules are in two tests (upgrade_and_discovery_deadlines,
stop_deadlines). All other tests use a grace period of 0 or core.stop,
poll with deadlines instead of sleeping, and use the persistent cache in
CARGO_TARGET_TMPDIR. The 128-cycle singleton test is an ignored stress
test that nix flake check runs; the normal run has a 4-cycle sample.
Warm, the activation suite takes 12 s (was 47 s), and cargo test
--workspace takes 65 s.

cli/tests/agent.rs

@@ -4,6 +4,7 @@ use http_body_util::{BodyExt, Full};
 use hyper::{Response, server::conn::http1, service::service_fn};
 use hyper_util::rt::TokioIo;
 use sausage::{Host, world::World};
+use sausage_vfs::Layer;
 use serde_json::{Value, json};
 use std::{convert::Infallible, path::PathBuf, sync::OnceLock, time::Duration};
 use tokio::{
@@ -114,7 +115,7 @@ fn fixtures() -> &'static PathBuf {
             .parent()
             .unwrap()
             .to_owned();
-        let target = root.join("target/sdk/agent-guests");
+        let target = PathBuf::from(concat!(env!("CARGO_TARGET_TMPDIR"), "/guests"));
         for args in [
             vec![
                 "build",
@@ -165,7 +166,7 @@ impl TestWorld {
     async fn start(&self) -> Host {
         Host::start_with_cache(
             &self.0,
-            &PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../target/sdk/agent-cache"),
+            std::path::Path::new(concat!(env!("CARGO_TARGET_TMPDIR"), "/cache")),
         )
         .await
         .unwrap()
@@ -349,24 +350,27 @@ async fn concurrent_chats_serialize_complete_turns() {
         let first = chat(&host, "first concurrent request");
         let (_, reply) = server.next().await;
         let second = chat(&host, "second concurrent request");
+        let view = host.filesystem().await.unwrap();
         tokio::time::timeout(Duration::from_secs(10), async {
-            while host
-                .processes()
-                .values()
-                .filter(|p| p.plugin == "agent" && p.method == "chat")
-                .count()
-                != 2
-            {
+            loop {
+                let file = view
+                    .open("/proc/core/locks.json", sausage_vfs::Open::default())
+                    .await
+                    .unwrap();
+                let locks: Value =
+                    serde_json::from_slice(&file.read(0, 65536).await.unwrap()).unwrap();
+                if locks["/state/agent/history.jsonl"]["waiting"]
+                    .as_array()
+                    .is_some_and(|waiting| waiting.len() == 1)
+                {
+                    break;
+                }
                 tokio::task::yield_now().await;
             }
         })
         .await
         .unwrap();
-        assert!(
-            tokio::time::timeout(Duration::from_millis(200), server.requests.recv())
-                .await
-                .is_err()
-        );
+        assert!(server.requests.try_recv().is_err());
         reply
             .send((200, server.answer("first concurrent answer", &[])))
             .unwrap();