host: review fixes for cargo.build, the test runner, the console, and main; tests for every PROTOCOL.md rule

cargo.build and the runner (review T22R): builds use the network again;
core.unlock and core.notify in order under the runner; quiet test
output; manifest preparation keeps [workspace], target tables, renamed
and optional entries; cargo.rpc.discover; -32004 with data.output;
retention of 10 builds; light, empty test worlds with an in-memory
journal; only CARGO_/RUST_/SAUSAGE_ variables; stdin is null; the runner
through --config. A compile cache that cannot be created is not fatal.
Activation replaces plugin.wasm without a gap.

Console and main: init ships the workspace Cargo.lock and creates the
world atomically; each console command runs in its own task, so ps,
stop, and kill work during a slow call; SAUSAGE_HEADLESS; the terminal
mode is restored; signals during boot; chat text is not taken as a
command.

Tests: 20 more tests for PROTOCOL.md sections 2 to 10; the cargo tests
choose the libtest binary from cargo's JSON output and time out.

cli/tests/sdk.rs

@@ -246,3 +246,122 @@ async fn secrets_fixed_endpoint() {
     assert_eq!(call(&host, "consumer.vault", json!({})).await, "hello");
     host.stop().await;
 }
+
+/// PROTOCOL 3.6: a background task retains its SDK process until the task completes.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn background_task_retains_process() {
+    let world = TestWorld::new();
+    let host = world.start().await;
+    let pid = call(&host, "probe.background_hold", json!({})).await;
+    assert!(host.processes().contains_key(pid.as_str().unwrap()));
+    assert_eq!(call(&host, "notes.list", json!({})).await, json!([]));
+    assert!(host.processes().contains_key(pid.as_str().unwrap()));
+    std::fs::write(world.0.join("release-background"), "release").unwrap();
+    tokio::time::timeout(Duration::from_secs(10), async {
+        while host.processes().contains_key(pid.as_str().unwrap()) {
+            tokio::task::yield_now().await;
+        }
+    })
+    .await
+    .unwrap();
+    assert_eq!(
+        std::fs::read_to_string(world.0.join("background-ended")).unwrap(),
+        "done"
+    );
+    host.stop().await;
+}
+
+/// PROTOCOL 5: stale endpoint identities and interfaces fail through genuine SDK processes.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn endpoint_handshake_rejects_mismatch() {
+    let world = TestWorld::new();
+    let host = world.start().await;
+    let pid = call(&host, "probe.service", json!({})).await;
+    let path = world.0.join("state/control");
+    let original = std::fs::read_to_string(&path).unwrap();
+    let words: Vec<_> = original.split_whitespace().collect();
+    for changed in [
+        format!("{} wrong-owner {}\n", words[0], words[2]),
+        format!("{} {} wrong-interface\n", words[0], words[1]),
+    ] {
+        std::fs::write(&path, changed).unwrap();
+        let error = host
+            .call("typed.world_endpoint", json!({}))
+            .await
+            .unwrap_err();
+        assert_eq!(error["code"], -32000);
+        assert!(error["message"].as_str().unwrap().contains("mismatch"));
+        assert!(host.processes().contains_key(pid.as_str().unwrap()));
+    }
+    std::fs::write(path, original).unwrap();
+    assert_eq!(call(&host, "typed.world_endpoint", json!({})).await, 7);
+    host.stop().await;
+}
+
+/// PROTOCOL 10.1 and 5: discovery through core retains params, endpoints, imports, and grace.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn discovery_extensions_through_core() {
+    let world = TestWorld::new();
+    let host = world.start().await;
+    let provider = call(&host, "probe.rpc.discover", json!({})).await;
+    assert_eq!(provider["openrpc"], "1.2.6");
+    assert_eq!(provider["x-sausage-grace"], 12);
+    assert!(
+        provider["x-sausage-endpoints"]["control"]["methods"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|m| m["name"] == "stats")
+    );
+    let add = provider["methods"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|m| m["name"] == "add")
+        .unwrap();
+    assert_eq!(add["paramStructure"], "by-name");
+    let reference = add["x-sausage-params"]["$ref"].as_str().unwrap();
+    assert_eq!(
+        provider.pointer(reference.trim_start_matches('#')).unwrap()["type"],
+        "object"
+    );
+    let consumer = call(&host, "typed.rpc.discover", json!({})).await;
+    assert!(
+        consumer["x-sausage-imports"]["probe"]["methods"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|m| m["name"] == "add")
+    );
+    host.stop().await;
+}
+
+/// PROTOCOL 3.2: rpc.discover is SDK control traffic and endpoint control is not a main method.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn reserved_rpc_control_names() {
+    let world = TestWorld::new();
+    let host = world.start().await;
+    assert!(call(&host, "probe.rpc.discover", json!({})).await["methods"].is_array());
+    for method in ["probe.rpc.endpoint", "probe.rpc.unknown"] {
+        assert_eq!(
+            host.call(method, json!({})).await.unwrap_err()["code"],
+            -32601
+        );
+    }
+    host.stop().await;
+}
+
+/// PROTOCOL 3.1: the SDK's leading newline isolates an unfinished diagnostic from its response.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn leading_newline_protects_sdk_response() {
+    let world = TestWorld::new();
+    let host = world.start().await;
+    assert_eq!(
+        call(&host, "probe.framed_output", json!({})).await,
+        "intact"
+    );
+    host.stop().await;
+    let warnings = call(&host, "core.log", json!({"grep":"discarded stdout"})).await;
+    assert_eq!(warnings.as_array().unwrap().len(), 1);
+    assert!(!warnings.to_string().contains("partial diagnostic"));
+}