cargo.build, the WASI test runner, the console, and core.notify ordering

- cargo.build (native): one source copy, tests under WASI, release
  build to /state/cargo/builds/<n>/, process groups killed on cancel.
  The host writes the SDK copy to /plugins/cargo/sdk/ at start.
- sausage test-runner: one instance per test, in parallel, with its own
  mount table (empty world, package folder at its path); answers
  core.lock, core.unlock, core.notify, core.log.
- The console: rustyline, notifications while typing, ls/cat through the
  process view, methods, ps, log, activate, revert, stop, kill.
- core.notify on stdout is handled in order, before the response.

cli/tests/crates/cargo-valid/Cargo.toml

@@ -3,4 +3,7 @@ name = "cargo-valid"
 version = "0.1.0"
 edition = "2024"
 
+[dependencies]
+sausage-plugin = "0.1"
+
 [workspace]

cli/tests/crates/cargo-valid/fixture.txt

@@ -0,0 +1 @@
+fixture

cli/tests/crates/cargo-valid/src/main.rs

@@ -1,9 +1,74 @@
-fn main() {}
-
+//! SDK plugin and tests for the native build pipeline.
+struct Plugin;
+#[sausage_plugin::rpc]
+impl Plugin {
+    /// Return a greeting.
+    fn hello(&self) -> sausage_plugin::Result<String> {
+        Ok("hello".into())
+    }
+}
+fn main() {
+    sausage_plugin::run(Plugin);
+}
 #[cfg(test)]
 mod tests {
     #[test]
-    fn unit_tests_run_on_the_host_target() {
+    fn arithmetic() {
         assert_eq!(2 + 2, 4);
     }
+    #[test]
+    fn fixture_at_manifest_path() {
+        assert_eq!(
+            std::fs::read_to_string(concat!(env!("CARGO_MANIFEST_DIR"), "/fixture.txt")).unwrap(),
+            "fixture\n"
+        );
+    }
+    #[test]
+    fn current_directory() {
+        println!(
+            "WASI_CURRENT_DIR={}",
+            std::env::current_dir().unwrap().display()
+        );
+    }
+    #[sausage_plugin::test]
+    async fn sdk_lock() {
+        let guard = sausage_plugin::lock("/state/lock").await.unwrap();
+        assert!(guard.held());
+        let mut guard = Some(guard);
+        let mut waiting = Box::pin(std::future::IntoFuture::into_future(sausage_plugin::lock(
+            "/state/lock",
+        )));
+        let acquired = std::future::poll_fn(|context| {
+            let result = std::future::Future::poll(waiting.as_mut(), context);
+            if result.is_pending() {
+                drop(guard.take());
+            }
+            result
+        })
+        .await
+        .unwrap();
+        assert!(acquired.held());
+        let logs = sausage_plugin::call("core.log", sausage_plugin::serde_json::json!({}))
+            .await
+            .unwrap();
+        assert!(logs.is_array());
+        sausage_plugin::call(
+            "core.notify",
+            sausage_plugin::serde_json::json!({"name":"progress","params":{}}),
+        )
+        .await
+        .unwrap();
+    }
+    #[sausage_plugin::test]
+    async fn other_plugin_fails() {
+        let error = sausage_plugin::call("missing.method", sausage_plugin::serde_json::json!({}))
+            .await
+            .unwrap_err();
+        assert!(error.to_string().contains("a test has no other plugins"));
+    }
+    #[test]
+    #[ignore]
+    fn ignored_case() {
+        assert_eq!(1, 1);
+    }
 }