Luigit
repositories / smith

smith

There are many coding harnesses - but this one is fast

owned by admin

smith-cli/tests/e2e_lifecycle.rs

Raw
//! SMH-SPEC-PLUG0001: real lifecycle components alter next wire request in eval and RPC.
//! SMH-SPEC-SPEC0001: durable request context and paired tool results.
use assert_cmd::Command;
use std::io::{BufRead, BufReader, Read, Write};
use std::net::{TcpListener, TcpStream};
use std::path::Path;
use std::time::Duration;
#[path = "../../smith-harness/tests/fixtures/lifecycle_support.rs"]
mod support;
fn smith(home: &Path) -> std::process::Command {
    let mut command = std::process::Command::new(assert_cmd::cargo::cargo_bin("smith"));
    command
        .current_dir(home)
        .env("HOME", home)
        .env("XDG_CONFIG_HOME", home.join("config"))
        .env("XDG_DATA_HOME", home.join("data"))
        .env("XDG_STATE_HOME", home.join("state"))
        .env("XDG_CACHE_HOME", home.join("cache"))
        .env("XDG_RUNTIME_DIR", home.join("runtime"))
        .env_remove("SMITH_PROVIDER")
        .env_remove("SMITH_MODEL")
        .env_remove("SMITH_BASE_URL")
        .env_remove("ANTHROPIC_API_KEY")
        .env_remove("OPENAI_API_KEY")
        .env_remove("GEMINI_API_KEY")
        .env_remove("GOOGLE_API_KEY");
    command
}

fn body(stream: &mut TcpStream) -> serde_json::Value {
    stream
        .set_read_timeout(Some(Duration::from_secs(10)))
        .unwrap();
    stream
        .set_write_timeout(Some(Duration::from_secs(10)))
        .unwrap();
    let mut request = Vec::new();
    let mut buffer = [0; 4096];
    let header_end = loop {
        let count = stream.read(&mut buffer).unwrap();
        assert!(count > 0 && request.len() + count <= 1 << 20);
        request.extend_from_slice(&buffer[..count]);
        if let Some(index) = request.windows(4).position(|bytes| bytes == b"\r\n\r\n") {
            break index + 4;
        }
    };
    let headers = std::str::from_utf8(&request[..header_end]).unwrap();
    let length: usize = headers
        .lines()
        .find_map(|line| {
            line.to_ascii_lowercase()
                .strip_prefix("content-length: ")
                .and_then(|value| value.trim().parse().ok())
        })
        .unwrap();
    assert!(header_end + length <= 1 << 20);
    while request.len() < header_end + length {
        let count = stream.read(&mut buffer).unwrap();
        assert!(count > 0);
        request.extend_from_slice(&buffer[..count]);
    }
    let body: serde_json::Value =
        serde_json::from_slice(&request[header_end..header_end + length]).unwrap();
    body
}

fn provider(rounds: usize, tool_followup: bool) -> (std::net::SocketAddr, Server) {
    provider_with_tool(
        rounds,
        tool_followup.then_some(("write", r#"{"path":"proof.txt","content":"evidence"}"#)),
    )
}

fn provider_with_tool(rounds: usize, tool: Option<(&str, &str)>) -> (std::net::SocketAddr, Server) {
    provider_tool_script(rounds, tool, false)
}

fn provider_tool_script(
    rounds: usize,
    tool: Option<(&str, &str)>,
    fail_followup: bool,
) -> (std::net::SocketAddr, Server) {
    let tool = tool.map(|(name, arguments)| (name.to_string(), arguments.to_string()));
    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    let address = listener.local_addr().unwrap();
    let (sender, receiver) = std::sync::mpsc::sync_channel(1);
    let (first_sender, first_request) = std::sync::mpsc::sync_channel(1);
    let worker = std::thread::spawn(move || {
        let mut requests = Vec::new();
        for text in ["first", "continued", "last", "last"]
            .into_iter()
            .take(rounds)
        {
            let (mut stream, _) = listener.accept().unwrap();
            requests.push(body(&mut stream));
            if text == "first" {
                first_sender.send(()).unwrap();
            }
            if fail_followup && text == "continued" {
                stream.write_all(b"HTTP/1.1 503 Unavailable\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}").unwrap();
                continue;
            }
            let response = if let Some((name, arguments)) = &tool
                && text == "first"
            {
                format!(
                    "data: {}\n\ndata: {}\n\ndata: [DONE]\n\n",
                    serde_json::json!({"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_lifecycle","type":"function","function":{"name":name,"arguments":arguments}}]},"finish_reason":null}]}),
                    serde_json::json!({"choices":[{"delta":{},"finish_reason":"tool_calls"}]})
                )
            } else {
                format!(
                    "data: {{\"choices\":[{{\"delta\":{{\"content\":\"{text}\"}}}}]}}\n\ndata: {{\"choices\":[{{\"delta\":{{}},\"finish_reason\":\"stop\"}}]}}\n\ndata: [DONE]\n\n"
                )
            };
            write!(stream, "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nConnection: close\r\nContent-Length: {}\r\n\r\n{response}", response.len()).unwrap();
        }
        sender.send(requests).unwrap();
    });
    (
        address,
        Server {
            address,
            receiver,
            first_request,
            worker: Some(worker),
        },
    )
}
struct Server {
    address: std::net::SocketAddr,
    receiver: std::sync::mpsc::Receiver<Vec<serde_json::Value>>,
    first_request: std::sync::mpsc::Receiver<()>,
    worker: Option<std::thread::JoinHandle<()>>,
}
impl Server {
    fn finish(mut self) -> Vec<serde_json::Value> {
        let requests = self
            .receiver
            .recv_timeout(Duration::from_secs(15))
            .expect("provider fixture must receive all expected requests before deadline");
        self.worker.take().unwrap().join().unwrap();
        requests
    }
}
impl Drop for Server {
    fn drop(&mut self) {
        if let Some(worker) = self.worker.take() {
            // Explicit shutdown signals unblock accept/read even when startup failed.
            for _ in 0..2 {
                let _wake = TcpStream::connect_timeout(&self.address, Duration::from_secs(1));
            }
            let _joined = worker.join();
        }
    }
}
fn install_decision(home: &Path, id: &str, actions: &str, required: bool) {
    install_boundary_decision(home, id, actions, required, "TurnComplete");
}
fn install_boundary_decision(home: &Path, id: &str, actions: &str, required: bool, boundary: &str) {
    let source = include_str!("../../smith-harness/tests/fixtures/lifecycle.rs")
        .replace("Boundary::TurnComplete", &format!("Boundary::{boundary}"))
        .replace("vec![Action::EnsureContinuation]", actions)
        .replace(
            "required_decision: false",
            &format!("required_decision: {required}"),
        );
    let source = if actions.starts_with("return Err") {
        source.replace(
            "        use exports::smith::plugin::lifecycle::*;\n        Ok(if",
            "        Ok(if",
        )
    } else {
        source
    };
    let source = if actions.contains("SetToolPolicy") {
        source.replace("fn declare_tools() -> Vec<plugin::ToolDeclaration> {\n        vec![]", "fn declare_tools() -> Vec<plugin::ToolDeclaration> {\n        vec![plugin::ToolDeclaration { name: \"controlled\".into(), description: \"controlled fixture\".into(), input_schema_json: \"{}\".into() }]")
    } else {
        source
    };
    let name = id.split_once(':').unwrap().1;
    let artifact =
        support::compile_fixture(&home.join(name), &source, &format!("lifecycle-{name}"));
    let registry =
        smith_harness::plugins::registry::PackageRegistry::at(home.join("config/smith/plugins"));
    support::install(
        &registry,
        &smith_harness::wasm::PluginEngine::new().unwrap(),
        &home.join(format!("package-{name}")),
        id,
        &artifact,
    );
}
fn assert_next_request(requests: &[serde_json::Value]) {
    assert_eq!(requests.len(), 2);
    assert!(
        requests[0]["messages"]
            .as_array()
            .unwrap()
            .iter()
            .any(|message| message["content"] == "raw-root")
    );
    assert!(!requests[0].to_string().contains("next-request-prompt"));
    let next = requests[1].to_string();
    assert!(next.contains("effective-root"));
    assert!(next.contains("next-request-prompt"));
    assert!(!next.contains("raw-root"));
}
#[test]
fn eval_two_sandbox_decisions_change_only_the_single_next_wire_request() {
    eval_continuation(false);
}
#[test]
fn eval_eligible_tool_followup_satisfies_both_continuations_with_paired_wire_results() {
    eval_continuation(true);
}
fn eval_continuation(tool_followup: bool) {
    let home = std::env::temp_dir().join(format!("smith-lifecycle-eval-{}", std::process::id()));
    std::fs::create_dir_all(&home).unwrap();
    support::install_consumers(&home, &home.join("config/smith/plugins"));
    install_decision(
        &home,
        "example:fault",
        "return Err(\"private-error\".into())",
        false,
    );
    install_decision(
        &home,
        "example:settings",
        "vec![Action::IncludeUsage(false), Action::SetModel(\"test-model\".into()), Action::SetProvider(\"openai-compatible-api\".into()), Action::SetToolPolicy(vec![ToolPolicyChange { name: \"example:settings/controlled\".into(), availability: Availability::Hidden }])]",
        false,
    );
    let (address, worker) = provider(2, tool_followup);
    let output = Command::from_std(smith(&home))
        .timeout(Duration::from_secs(30))
        .env("OPENAI_API_KEY", "lifecycle-fixture-secret")
        .args([
            "eval",
            "--provider",
            "openai",
            "--model",
            "test-model",
            "--base-url",
            &format!("http://{address}/v1"),
            "raw-root",
        ])
        .output()
        .unwrap();
    if !output.status.success() {
        for _ in 0..2 {
            let _wake = TcpStream::connect_timeout(&address, Duration::from_secs(1));
        }
    }
    let requests = worker.finish();
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert_eq!(output.stdout, b"continued\n");
    assert_next_request(&requests);
    if tool_followup {
        assert_eq!(
            std::fs::read_to_string(home.join("proof.txt")).unwrap(),
            "evidence"
        );
        let messages = requests[1]["messages"].as_array().unwrap();
        let call = messages
            .iter()
            .find(|message| message["role"] == "assistant" && message["tool_calls"].is_array())
            .unwrap();
        let result = messages
            .iter()
            .find(|message| message["role"] == "tool")
            .unwrap();
        assert_eq!(call["tool_calls"][0]["id"], result["tool_call_id"]);
        assert_eq!(
            messages
                .iter()
                .filter(|message| message["role"] == "tool")
                .count(),
            1
        );
    }

    assert!(
        requests[0]["tools"]
            .as_array()
            .unwrap()
            .iter()
            .any(|tool| tool["function"]["name"] == "example:settings/controlled")
    );
    assert!(
        !requests[1]["tools"]
            .as_array()
            .unwrap()
            .iter()
            .any(|tool| tool["function"]["name"] == "example:settings/controlled")
    );
    assert_eq!(requests[1]["model"], "test-model");
    assert_eq!(requests[0]["stream_options"]["include_usage"], true);
    assert_eq!(requests[1]["stream_options"]["include_usage"], false);
    assert!(!String::from_utf8_lossy(&output.stdout).contains("lifecycle-fixture-secret"));
    let sessions = std::fs::read_dir(home.join("data/smith/sessions/run")).unwrap();
    let path = sessions
        .filter_map(Result::ok)
        .map(|entry| entry.path())
        .find(|path| path.extension().is_some_and(|extension| extension == "smh"))
        .unwrap();
    let session = smith_core::store::SessionReader::open(&path)
        .unwrap()
        .selected_session(smith::Config::default_valid().frame_bytes_max)
        .unwrap();
    let raw: Vec<_> = session
        .active_branch()
        .entries()
        .iter()
        .map(|entry| session.content(entry).unwrap())
        .collect();
    assert!(format!("{raw:?}").contains("raw-root"));
    assert!(format!("{raw:?}").contains("lifecycle_decision"));
    let root_id = session.active_branch().entries().iter().find(|entry| matches!(session.content(entry).unwrap(), smith_core::session::EntryContent::Message(message) if message.role == smith::Role::User)).unwrap().id;
    let records: Vec<_> = raw
        .iter()
        .filter_map(|entry| match entry {
            smith_core::session::EntryContent::Meta { kind, detail }
                if kind == "lifecycle_decision" =>
            {
                Some(
                    detail
                        .deserialize_as::<(
                            smith::lifecycle::LifecycleEvent,
                            smith::lifecycle::LifecycleBatch,
                        )>()
                        .unwrap(),
                )
            }
            _ => None,
        })
        .collect();
    let trace = records
        .iter()
        .map(|(event, batch)| {
            assert_eq!(event.root_entry_id, root_id);
            let names = batch
                .actions
                .iter()
                .map(|action| match serde_json::to_value(action).unwrap() {
                    serde_json::Value::String(name) => name,
                    serde_json::Value::Object(object) => object.into_iter().next().unwrap().0,
                    _ => unreachable!(),
                })
                .collect::<Vec<_>>()
                .join("|");
            let diagnostics = batch
                .diagnostics
                .iter()
                .map(|diagnostic| format!("{:?}", diagnostic.code))
                .collect::<Vec<_>>()
                .join("|");
            format!(
                "{:?}[{}] {:?} root=$root eligible={} actions={names} diagnostics={diagnostics}\n",
                event.boundary, event.round_index, event.last_stop, event.continuation_eligible
            )
        })
        .collect::<String>();
    if tool_followup {
        insta::assert_snapshot!(trace, @r#"
        TurnComplete[0] ToolUse root=$root eligible=true actions=EnsureContinuation|EditContext|EnsureContinuation|SetPrompt|IncludeUsage|SetModel|SetProvider|SetToolPolicy diagnostics=HandlerFailed
        TurnComplete[1] EndTurn root=$root eligible=true actions= diagnostics=
        "#);
    } else {
        insta::assert_snapshot!(trace, @r#"
        TurnComplete[0] EndTurn root=$root eligible=true actions=EnsureContinuation|EditContext|EnsureContinuation|SetPrompt|IncludeUsage|SetModel|SetProvider|SetToolPolicy diagnostics=HandlerFailed
        TurnComplete[1] EndTurn root=$root eligible=true actions= diagnostics=
        "#);
    }
    let diagnostics: Vec<_> = raw
        .iter()
        .filter_map(|entry| match entry {
            smith_core::session::EntryContent::Meta { kind, detail }
                if kind == "lifecycle_decision" =>
            {
                Some(
                    detail
                        .deserialize_as::<(
                            smith::lifecycle::LifecycleEvent,
                            smith::lifecycle::LifecycleBatch,
                        )>()
                        .unwrap()
                        .1
                        .diagnostics,
                )
            }
            _ => None,
        })
        .flatten()
        .collect();
    assert_eq!(diagnostics.len(), 1);
    insta::allow_duplicates! {
    insta::assert_snapshot!(serde_json::to_string_pretty(&diagnostics).unwrap(), @r#"
    [
      {
        "component": "example:fault",
        "handler": "continue",
        "code": "HandlerFailed"
      }
    ]
    "#);
    }
    std::fs::remove_dir_all(home).unwrap();
}

struct Child(std::process::Child);
impl Drop for Child {
    fn drop(&mut self) {
        let _ = self.0.kill();
        let _ = self.0.wait();
    }
}
#[test]
fn rpc_two_sandbox_decisions_settle_one_root_after_one_continuation() {
    rpc_scenario(None, false);
}
#[test]
fn rpc_required_decision_failure_discards_context_and_continuation_with_one_terminal_error() {
    rpc_scenario(Some("vec![Action::SetModel(\"unavailable\".into())]"), true);
}
#[test]
fn rpc_conflicting_context_writes_reject_the_entire_non_cancel_batch() {
    rpc_scenario(
        Some(
            "vec![Action::EditContext(vec![ContextEdit { target: event.root_entry_id, replacement: Some(Replacement::Text(\"conflicting-root\".into())) }])]",
        ),
        false,
    );
}
#[test]
fn rpc_conflicting_tool_availability_rejects_the_entire_non_cancel_batch() {
    rpc_scenario(
        Some(
            "vec![Action::SetToolPolicy(vec![ToolPolicyChange { name: \"example:conflict/controlled\".into(), availability: Availability::Hidden }, ToolPolicyChange { name: \"example:conflict/controlled\".into(), availability: Availability::Disabled }])]",
        ),
        false,
    );
}
fn rpc_scenario(actions: Option<&str>, required: bool) {
    static NEXT: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
    use std::process::Stdio;
    let home = std::env::temp_dir().join(format!(
        "slr-{}-{}",
        std::process::id(),
        NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
    ));
    std::fs::create_dir_all(&home).unwrap();
    support::install_consumers(&home, &home.join("config/smith/plugins"));
    if let Some(actions) = actions {
        install_decision(&home, "example:conflict", actions, required);
    }
    let (address, worker) = provider(if actions.is_some() { 1 } else { 2 }, false);
    let mut command = smith(&home);
    command
        .env("OPENAI_API_KEY", "lifecycle-fixture-secret")
        .args([
            "rpc",
            "--provider",
            "openai",
            "--model",
            "test-model",
            "--base-url",
            &format!("http://{address}/v1"),
        ]);
    let mut child = Child(
        command
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
            .unwrap(),
    );
    let mut input = child.0.stdin.take().unwrap();
    writeln!(input, "{{\"id\":1,\"method\":\"prompt\",\"params\":{{\"input\":\"raw-root\"}}}}\n{{\"id\":2,\"method\":\"wait\"}}").unwrap();
    input.flush().unwrap();
    let stdout = child.0.stdout.take().unwrap();
    let (sender, receiver) = std::sync::mpsc::sync_channel(16);
    let reader = std::thread::spawn(move || {
        let mut reader = BufReader::new(stdout);
        loop {
            let mut line = Vec::new();
            if reader.read_until(b'\n', &mut line).unwrap() == 0 {
                break;
            }
            assert!(
                line.len() <= 65536 && line.ends_with(b"\n") && !line.contains(&b'\r'),
                "RPC wire must be bounded LF-only JSON lines"
            );
            if sender.send(String::from_utf8(line).unwrap()).is_err() {
                break;
            }
        }
    });
    let mut lines = Vec::new();
    for _ in 0..8 {
        let value: serde_json::Value =
            serde_json::from_str(&receiver.recv_timeout(Duration::from_secs(30)).unwrap()).unwrap();
        let done = value["id"] == 2;
        lines.push(value);
        if done {
            break;
        }
    }
    if required {
        assert_eq!(
            lines
                .iter()
                .filter(|line| line["error"]["code"] == "TURN_FAILED")
                .count(),
            1
        );
        assert_eq!(
            lines.iter().filter(|line| line["event"] == "end").count(),
            1
        );
    } else {
        assert_eq!(
            lines.iter().filter(|line| line["event"] == "end").count(),
            1
        );
        assert!(
            lines.iter().any(|line| line["event"] == "end"
                && line["text"]
                    == if actions.is_some() {
                        "first"
                    } else {
                        "continued"
                    }),
            "{lines:?}"
        );
    }
    assert_eq!(
        lines.last().unwrap(),
        &serde_json::json!({"id":2,"settled":true})
    );
    if actions.is_none() {
        let mut normalized = lines.clone();
        normalized[0]["receipt"]["session_id"] = "$session".into();
        normalized[0]["receipt"]["submission_id"] = "$root".into();
        let wire = normalized
            .iter()
            .map(|line| serde_json::to_string(line).unwrap() + "\n")
            .collect::<String>();
        insta::assert_snapshot!(wire, @r#"
        {"id":1,"event":"start","receipt":{"session_id":"$session","submission_id":"$root","destination":null,"status":"Queued","cancel_requested":false}}
        {"id":1,"event":"delta","text":"first"}
        {"id":1,"event":"delta","text":"continued"}
        {"id":1,"event":"end","text":"continued","reason":"EndTurn","cost":null,"cost_complete":false}
        {"id":2,"settled":true}
        "#);
    }
    drop(input);
    assert!(matches!(
        receiver.recv_timeout(Duration::from_secs(10)),
        Err(std::sync::mpsc::RecvTimeoutError::Disconnected)
    ));
    assert!(child.0.wait().unwrap().success());
    reader.join().unwrap();
    let requests = worker.finish();
    if actions.is_none() {
        assert_next_request(&requests);
    } else {
        assert_eq!(requests.len(), 1);
        let path = std::fs::read_dir(home.join("data/smith/sessions/run"))
            .unwrap()
            .filter_map(Result::ok)
            .map(|entry| entry.path())
            .find(|path| path.extension().is_some_and(|extension| extension == "smh"))
            .unwrap();
        let session = smith_core::store::SessionReader::open(&path)
            .unwrap()
            .selected_session(smith::Config::default_valid().frame_bytes_max)
            .unwrap();
        let projected = format!("{:?}", session.projected_messages().unwrap());
        assert!(projected.contains("raw-root"));
        assert!(!projected.contains("effective-root"));
        assert!(!projected.contains("next-request-prompt"));
    }
    std::fs::remove_dir_all(home).unwrap();
}

#[test]
fn eval_pre_settlement_handler_performs_one_durably_owned_http_effect() {
    eval_lifecycle_http_effect("PreSettlement");
}

#[test]
fn eval_settled_handler_performs_one_durably_owned_http_effect() {
    eval_lifecycle_http_effect("Settled");
}

fn eval_lifecycle_http_effect(boundary: &str) {
    let home = std::env::temp_dir().join(format!("sle-{:x}", smith::SessionId::new().as_u128()));
    std::fs::create_dir_all(&home).unwrap();
    let (address, worker) = provider(1, false);
    let effect_listener = TcpListener::bind("127.0.0.1:0").unwrap();
    let effect_address = effect_listener.local_addr().unwrap();
    let origin = format!("http://{effect_address}");
    let (sent, received) = std::sync::mpsc::sync_channel(1);
    let server_home = home.clone();
    let effect_worker = std::thread::spawn(move || {
        let (mut stream, _) = effect_listener.accept().unwrap();
        stream
            .set_read_timeout(Some(Duration::from_secs(5)))
            .unwrap();
        let mut bytes = [0u8; 4096];
        let length = stream.read(&mut bytes).unwrap();
        assert!(length > 0);
        let path = std::fs::read_dir(server_home.join("data/smith/sessions/run"))
            .unwrap()
            .filter_map(Result::ok)
            .map(|entry| entry.path())
            .find(|path| path.extension().is_some_and(|ext| ext == "smh"))
            .unwrap();
        let session = smith_core::store::SessionReader::open(&path)
            .unwrap()
            .selected_session(smith::Config::default_valid().frame_bytes_max)
            .unwrap();
        assert!(session.active_branch().entries().iter().any(|entry|
            matches!(session.content(entry).unwrap(), smith_core::session::EntryContent::Meta { kind, .. } if kind == "lifecycle-effect-intent")));
        stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 23\r\nConnection: close\r\n\r\nlifecycle-effect-secret").unwrap();
        sent.send(()).unwrap();
    });
    let source = include_str!("../../smith-harness/tests/fixtures/lifecycle.rs")
        .replace("Boundary::TurnComplete", &format!("Boundary::{boundary}"))
        .replace("vec![Action::EnsureContinuation]", &format!(r#"{{
            let mut request = smith::plugin::net_scope::HttpRequest {{
                destination: "{origin}".into(), method: "POST".into(), headers: vec![],
                body: b"lifecycle-effect-secret".to_vec(),
                options: smith::plugin::net_scope::RequestOptions {{ timeout_ms: 1000, response_bytes_max: 256 }},
            }};
            request.options.response_bytes_max = 257;
            if smith::plugin::net_scope::request(&request).is_ok() {{ return Err("oversized response cap accepted".into()); }}
            request.options.response_bytes_max = 256;
            let response = smith::plugin::net_scope::request(&request)?;
            if response.status != 200 {{ return Err("HTTP failed".into()); }}
            vec![]
        }}"#));
    let source = source.replace(
        "        use exports::smith::plugin::lifecycle::*;\n        Ok(if",
        "        Ok(if",
    );
    let artifact = support::compile_fixture(&home.join("guest"), &source, "lifecycle-effect");
    let package = home.join("package");
    std::fs::create_dir_all(&package).unwrap();
    std::fs::copy(artifact, package.join("fixture.wasm")).unwrap();
    std::fs::write(package.join("plugin.kdl"),
        "id \"example:lifecycle-http\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"fixture.wasm\"\ncapability \"net-scope\"\n").unwrap();
    let install = Command::from_std(smith(&home))
        .args([
            "plugin",
            "install",
            package.to_str().unwrap(),
            "--grant",
            "net-scope",
            "--net-origin",
            &origin,
        ])
        .output()
        .unwrap();
    assert!(
        install.status.success(),
        "{}",
        String::from_utf8_lossy(&install.stderr)
    );
    let output = Command::from_std(smith(&home))
        .timeout(Duration::from_secs(20))
        .env("OPENAI_API_KEY", "lifecycle-effect-secret")
        .args([
            "eval",
            "--provider",
            "openai",
            "--model",
            "test-model",
            "--base-url",
            &format!("http://{address}/v1"),
            "raw-root",
        ])
        .output()
        .unwrap();
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    let requests = worker.finish();
    assert!(
        output.status.success(),
        "{}",
        String::from_utf8_lossy(&output.stderr)
    );
    assert_eq!(requests.len(), 1);
    received
        .recv_timeout(Duration::from_secs(3))
        .expect("lifecycle must perform real HTTP");
    effect_worker.join().unwrap();
    let path = std::fs::read_dir(home.join("data/smith/sessions/run"))
        .unwrap()
        .filter_map(Result::ok)
        .map(|entry| entry.path())
        .find(|path| path.extension().is_some_and(|extension| extension == "smh"))
        .unwrap();
    let session = smith_core::store::SessionReader::open(&path)
        .unwrap()
        .selected_session(smith::Config::default_valid().frame_bytes_max)
        .unwrap();
    for entry in session.active_branch().entries() {
        let content = format!("{:?}", session.content(entry).unwrap());
        assert!(!content.contains("lifecycle-effect-secret"));
        assert!(
            !content.contains("6c6966656379636c652d6566666563742d736563726574"),
            "hex must not bypass secret masking"
        );
    }
    let root_id = session
        .active_branch()
        .entries()
        .iter()
        .find(|entry| {
            matches!(
                entry.kind,
                smith_core::session::EntryKind::Message {
                    role: smith::message::Role::User,
                    ..
                }
            )
        })
        .unwrap()
        .id;
    let mut invocation_id = None;
    let mut effect_id = None;
    let mut kinds = Vec::new();
    for entry in session.active_branch().entries().iter() {
        let content = session.content(entry).unwrap();
        assert!(!matches!(
            content,
            smith_core::session::EntryContent::ToolCall { .. }
                | smith_core::session::EntryContent::ToolResult { .. }
        ));
        if let smith_core::session::EntryContent::Meta { kind, detail } = content {
            if smith_core::metadata::lifecycle::reserved(&kind) {
                let detail = serde_json::to_value(detail).unwrap();
                assert_eq!(detail["root_entry_id"], serde_json::json!(root_id));
                assert!(detail.get("call_id").is_none());
                if kind == smith_core::metadata::lifecycle::INVOCATION_INTENT {
                    invocation_id = Some(entry.id);
                }
                assert_eq!(
                    detail["invocation_id"],
                    serde_json::json!(invocation_id.unwrap())
                );
                if kind == smith_core::metadata::lifecycle::EFFECT_INTENT {
                    effect_id = Some(entry.id);
                }
                if kind.starts_with("lifecycle-effect-") {
                    assert_eq!(detail["effect_id"], serde_json::json!(effect_id.unwrap()));
                    assert_eq!(detail["ordinal"], 0);
                }
            }
            if kind.starts_with("lifecycle-") && kind != "lifecycle-decision" {
                kinds.push(kind);
            }
        }
    }
    assert_eq!(
        kinds,
        [
            "lifecycle-invocation-intent",
            "lifecycle-effect-intent",
            "lifecycle-effect-completion",
            "lifecycle-invocation-completion"
        ]
    );
}

fn install_settled_http(home: &Path, origin: &str) {
    install_boundary_http(home, origin, "Settled", false);
}

fn install_boundary_http(home: &Path, origin: &str, boundary: &str, actionable: bool) {
    let source = include_str!("../../smith-harness/tests/fixtures/lifecycle.rs")
        .replace("Boundary::TurnComplete", &format!("Boundary::{boundary}"))
        .replace("vec![Action::EnsureContinuation]", &format!(r#"{{
            let response = smith::plugin::net_scope::request(&smith::plugin::net_scope::HttpRequest {{
                destination: "{origin}".into(), method: "POST".into(), headers: vec![],
                body: b"{{}}".to_vec(),
                options: smith::plugin::net_scope::RequestOptions {{ timeout_ms: 10000, response_bytes_max: 256 }},
            }})?;
            if response.status != 200 {{ return Err("HTTP failed".into()); }}
            vec![]
        }}"#))
        .replace("        use exports::smith::plugin::lifecycle::*;\n        Ok(if", "        Ok(if");
    let id = if actionable {
        "example:actionable-http"
    } else {
        "example:notification-http"
    };
    let artifact = support::compile_fixture(
        &home.join(format!("guest-{boundary}")),
        &source,
        if actionable {
            "actionable-http"
        } else {
            "settled-http"
        },
    );

    let package = home.join(format!("http-package-{boundary}"));
    std::fs::create_dir_all(&package).unwrap();
    std::fs::copy(artifact, package.join("fixture.wasm")).unwrap();
    std::fs::write(package.join("plugin.kdl"), format!("id \"{id}\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"fixture.wasm\"\ncapability \"net-scope\"\n")).unwrap();
    Command::from_std(smith(home))
        .args([
            "plugin",
            "install",
            package.to_str().unwrap(),
            "--grant",
            "net-scope",
            "--net-origin",
            origin,
        ])
        .assert()
        .success();
}

fn install_notification_composition(home: &Path, cancel: bool) {
    let source = include_str!("../../smith-harness/tests/fixtures/composition.rs")
        .replace("WIT_PATH", "wit")
        .replace(
            "return Ok(\"child complete\".into());",
            if cancel {
                "loop { core::hint::spin_loop(); }"
            } else {
                "return Ok(\"child complete\".into());"
            },
        );
    let artifact = support::compile_fixture(
        &home.join("composition-guest"),
        &source,
        "notification-composition",
    );
    for id in ["a", "target"] {
        let package = home.join(format!("composition-{id}"));
        std::fs::create_dir_all(&package).unwrap();
        std::fs::copy(&artifact, package.join("fixture.wasm")).unwrap();
        std::fs::write(package.join("plugin.kdl"), format!("id \"fixture:{id}\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"fixture.wasm\"\ncapability \"workspace\"\n")).unwrap();
        Command::from_std(smith(home))
            .args([
                "plugin",
                "install",
                package.to_str().unwrap(),
                "--grant",
                "workspace",
            ])
            .assert()
            .success();
    }
    std::fs::create_dir(home.join("A")).unwrap();
}

// Observe the real atomic file effect, not a production readiness hook.
// Register before startup; arm the deadline only when the provider is ready.
#[cfg(target_os = "linux")]
fn child_write_signal(directory: &Path) -> impl FnOnce() + use<> {
    use std::os::fd::{AsRawFd, FromRawFd};
    use std::os::unix::ffi::OsStrExt;
    #[repr(C)]
    struct PollDescriptor {
        descriptor: i32,
        events: i16,
        returned: i16,
    }
    unsafe extern "C" {
        fn inotify_init1(flags: i32) -> i32;
        fn inotify_add_watch(descriptor: i32, path: *const std::ffi::c_char, mask: u32) -> i32;
        fn poll(descriptors: *mut PollDescriptor, count: usize, timeout: i32) -> i32;
    }
    // SAFETY: CLOEXEC produces an owned descriptor, checked before adoption.
    let descriptor = unsafe { inotify_init1(0x80000) };
    assert!(descriptor >= 0);
    // SAFETY: successful init returned a fresh descriptor owned only here.
    let mut events = unsafe { std::fs::File::from_raw_fd(descriptor) };
    let path = std::ffi::CString::new(directory.as_os_str().as_bytes()).unwrap();
    // SAFETY: live descriptor and terminated path remain valid for this call.
    assert!(unsafe { inotify_add_watch(events.as_raw_fd(), path.as_ptr(), 0x80) } >= 0);
    move || {
        let mut descriptor = PollDescriptor {
            descriptor: events.as_raw_fd(),
            events: 1,
            returned: 0,
        };
        // SAFETY: one initialized descriptor is writable for the duration of poll.
        assert_eq!(
            unsafe { poll(&raw mut descriptor, 1, 20000) },
            1,
            "child file-effect deadline"
        );
        let mut bytes = [0; 4096];
        let count = events.read(&mut bytes).unwrap();
        assert!(
            bytes[..count]
                .windows(b"written.txt\0".len())
                .any(|name| name == b"written.txt\0")
        );
    }
}

#[cfg(target_os = "linux")]
#[test]
fn child_file_effect_signal_retains_events_before_wait() {
    let root = std::env::temp_dir().join(format!("smith-child-signal-{}", smith::SessionId::new()));
    std::fs::create_dir_all(&root).unwrap();
    let wait = child_write_signal(&root);
    std::fs::write(root.join("pending"), b"evidence").unwrap();
    std::fs::rename(root.join("pending"), root.join("written.txt")).unwrap();
    wait();
    std::fs::remove_dir_all(root).unwrap();
}

#[test]
fn rpc_settled_notifications_defer_both_delivery_modes_until_cleanup() {
    rpc_notification_queue(false, false, None);
}

#[test]
fn rpc_settled_notifications_defer_after_turn_first_until_cleanup() {
    rpc_notification_queue_order(false, false, None, true);
}

#[test]
fn rpc_cancelled_root_finishes_bounded_notifications_before_wait_and_queued_work() {
    rpc_notification_queue(true, false, None);
}

#[test]
fn rpc_required_failure_retains_completed_write_and_notification_queue() {
    rpc_notification_queue(false, true, None);
}

#[test]
fn rpc_cancel_decision_retains_completed_write_and_runs_bounded_notification_cleanup() {
    rpc_notification_queue(true, true, None);
}

#[cfg(target_os = "linux")]
#[test]
fn rpc_cancelled_structured_child_joins_before_notifications_and_queued_work() {
    rpc_notification_queue(true, false, Some("caller"));
}

#[test]
fn rpc_parent_failure_retains_completed_child_write_and_notification_queue() {
    rpc_notification_queue(false, false, Some("parent-fail"));
}

fn rpc_notification_queue(cancel: bool, required_failure: bool, composition: Option<&str>) {
    rpc_notification_queue_order(cancel, required_failure, composition, false);
}

fn rpc_notification_queue_order(
    cancel: bool,
    required_failure: bool,
    composition: Option<&str>,
    after_first: bool,
) {
    rpc_notification_scenario(cancel, required_failure, composition, after_first, false);
}

#[test]
fn rpc_abort_actionable_http_acknowledges_invocation_before_settlement() {
    rpc_notification_scenario(true, false, None, false, true);
}

fn rpc_notification_scenario(
    cancel: bool,
    required_failure: bool,
    composition: Option<&str>,
    after_first: bool,
    actionable_cancel: bool,
) {
    use std::process::Stdio;
    let home = std::env::temp_dir().join(format!("sln-{:x}", smith::SessionId::new().as_u128()));
    std::fs::create_dir_all(&home).unwrap();
    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    let origin = format!("http://{}", listener.local_addr().unwrap());
    install_settled_http(&home, &origin);
    let actionable = actionable_cancel.then(|| {
        let listener = TcpListener::bind("127.0.0.1:0").unwrap();
        install_boundary_http(&home, &format!("http://{}", listener.local_addr().unwrap()), "PreSettlement", true);
        let (ready_tx, ready_rx) = std::sync::mpsc::sync_channel(1);
        let (cancelled_tx, cancelled_rx) = std::sync::mpsc::sync_channel(1);
        let server_home = home.clone();
        let worker = std::thread::spawn(move || {
            for index in 0..3 {
                let (mut stream, _) = listener.accept().unwrap();
                stream.set_read_timeout(Some(Duration::from_secs(10))).unwrap();
                assert_eq!(body(&mut stream), serde_json::json!({}));
                let session = smith_core::store::SessionReader::open(&session_path(&server_home)).unwrap()
                    .selected_session(smith::Config::default_valid().frame_bytes_max).unwrap();
                let last = session.active_branch().entries().last().unwrap();
                assert!(matches!(session.content(last).unwrap(), smith_core::session::EntryContent::Meta { kind, .. } if kind == "lifecycle-effect-intent"));
                if index == 0 {
                    ready_tx.send(()).unwrap();
                    let mut byte = [0];
                    assert_eq!(stream.read(&mut byte).expect("HTTP cancellation closes connection"), 0);
                    cancelled_tx.send(()).unwrap();
                } else {
                    stream.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}").unwrap();
                }
            }
        });
        (ready_rx, cancelled_rx, worker)
    });
    // A failed notification must not suppress the HTTP consumer; actions from a
    // distinct later consumer must not reopen provider work.
    install_boundary_decision(
        &home,
        "example:notification-fault",
        "return Err(\"private-notification-error\".into())",
        false,
        "Settled",
    );
    install_boundary_decision(
        &home,
        "example:notification-reopen",
        "vec![Action::EnsureContinuation]",
        false,
        "Settled",
    );
    const NOTIFICATION_COUNT: usize = 3;
    // All reports must fit while the client waits for settlement before draining them.
    let (ready_tx, ready_rx) = std::sync::mpsc::sync_channel(NOTIFICATION_COUNT);
    let (release_tx, release_rx) = std::sync::mpsc::sync_channel(1);
    let server_home = home.clone();
    let effect_worker = std::thread::spawn(move || {
        for index in 0..NOTIFICATION_COUNT {
            let (mut stream, _) = listener.accept().unwrap();
            assert_eq!(body(&mut stream), serde_json::json!({}));
            let path = session_path(&server_home);
            let session = smith_core::store::SessionReader::open(&path)
                .unwrap()
                .selected_session(smith::Config::default_valid().frame_bytes_max)
                .unwrap();
            let kinds: Vec<_> = session
                .active_branch()
                .entries()
                .iter()
                .filter_map(|entry| match session.content(entry).unwrap() {
                    smith_core::session::EntryContent::Meta { kind, .. } => Some(kind),
                    _ => None,
                })
                .collect();
            assert_eq!(
                kinds.last().unwrap(),
                "lifecycle-effect-intent",
                "guest HTTP requires prior durable acknowledgement"
            );
            ready_tx.send(index).unwrap();
            if index == 0 {
                release_rx
                    .recv_timeout(Duration::from_secs(10))
                    .expect("explicit notification release");
            }
            stream
                .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}")
                .unwrap();
        }
    });
    if required_failure {
        install_decision(
            &home,
            "example:required",
            if cancel {
                "vec![Action::Cancel, Action::SetModel(\"unavailable\".into())]"
            } else {
                "vec![Action::SetModel(\"unavailable\".into())]"
            },
            true,
        );
    }
    if composition.is_some() {
        install_notification_composition(&home, cancel);
    }
    #[cfg(target_os = "linux")]
    let child_effect =
        (composition.is_some() && cancel).then(|| child_write_signal(&home.join("A")));
    #[cfg(not(target_os = "linux"))]
    let child_effect: Option<fn()> = None;
    let (address, provider_worker) = composition.map_or_else(
        || provider(3, required_failure),
        |mode| {
            provider_tool_script(
                if cancel { 3 } else { 4 },
                Some(("fixture:a/fixture", &format!(r#"{{"mode":"{mode}"}}"#))),
                !cancel,
            )
        },
    );
    let mut invocation = smith(&home);
    invocation.arg("rpc");
    if composition.is_some() {
        invocation.args([
            "--tool-policy",
            "fixture:target/fixture=hidden",
            "--tool-delegation",
            "fixture:a/fixture=fixture:target/fixture#A",
        ]);
    }
    let mut child = Child(
        invocation
            .env("OPENAI_API_KEY", "settled-fixture-secret")
            .args([
                "--provider",
                "openai",
                "--model",
                "test-model",
                "--base-url",
                &format!("http://{address}/v1"),
            ])
            .stdin(Stdio::piped())
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
            .unwrap(),
    );
    let mut input = child.0.stdin.take().unwrap();
    let stdout = child.0.stdout.take().unwrap();
    let (sender, receiver) = std::sync::mpsc::sync_channel(32);
    let reader = std::thread::spawn(move || {
        for line in BufReader::new(stdout).lines() {
            if sender
                .send(serde_json::from_str::<serde_json::Value>(&line.unwrap()).unwrap())
                .is_err()
            {
                break;
            }
        }
    });
    let mut lines = Vec::new();
    let mut receive = |id: u64| {
        for _ in 0..32 {
            let line = receiver
                .recv_timeout(Duration::from_secs(20))
                .expect("bounded RPC response");
            let found = line["id"] == id;
            lines.push(line.clone());
            if found {
                return line;
            }
        }
        panic!("response identity not found");
    };
    writeln!(
        input,
        "{{\"id\":1,\"method\":\"prompt\",\"params\":{{\"input\":\"raw-root\"}}}}"
    )
    .unwrap();
    input.flush().unwrap();
    let root = receive(1)["receipt"]["submission_id"].clone();
    if let Some(wait) = child_effect {
        provider_worker
            .first_request
            .recv_timeout(Duration::from_secs(20))
            .expect("provider must receive the root request before child execution");
        wait();
        writeln!(
            input,
            "{{\"id\":9,\"method\":\"abort\",\"params\":{{\"id\":{root}}}}}"
        )
        .unwrap();
        input.flush().unwrap();
        assert_eq!(receive(9)["aborting"], true);
    }
    let actionable_worker = if let Some((ready, cancelled, worker)) = actionable {
        ready.recv_timeout(Duration::from_secs(20)).unwrap();
        writeln!(
            input,
            "{{\"id\":19,\"method\":\"abort\",\"params\":{{\"id\":{root}}}}}"
        )
        .unwrap();
        input.flush().unwrap();
        assert_eq!(receive(19)["aborting"], true);
        cancelled
            .recv_timeout(Duration::from_secs(10))
            .expect("actionable HTTP canceled");
        Some(worker)
    } else {
        None
    };
    let notification = ready_rx.recv_timeout(Duration::from_secs(20));
    if actionable_cancel && notification.is_err() {
        let session = smith_core::store::SessionReader::open(&session_path(&home))
            .unwrap()
            .selected_session(smith::Config::default_valid().frame_bytes_max)
            .unwrap();
        let mut open = 0;
        for entry in session.active_branch().entries() {
            if let smith_core::session::EntryContent::Meta { kind, .. } =
                session.content(entry).unwrap()
            {
                match kind.as_str() {
                    "lifecycle-invocation-intent" => open += 1,
                    "lifecycle-invocation-completion" => open -= 1,
                    _ => {}
                }
            }
        }
        assert_eq!(
            open, 0,
            "canceled actionable handler must acknowledge invocation completion before Cancelled"
        );
    }
    assert_eq!(notification.unwrap(), 0);
    let (first_delivery, second_delivery) = if after_first {
        ("AfterTurn", "BetweenRequests")
    } else {
        ("BetweenRequests", "AfterTurn")
    };
    writeln!(input, "{{\"id\":2,\"method\":\"prompt\",\"params\":{{\"input\":\"queued-between\",\"key\":\"between-key\",\"delivery\":\"{first_delivery}\"}}}}\n{{\"id\":3,\"method\":\"prompt\",\"params\":{{\"input\":\"queued-after\",\"key\":\"after-key\",\"delivery\":\"{second_delivery}\"}}}}\n{{\"id\":4,\"method\":\"prompt\",\"params\":{{\"input\":\"queued-between\",\"key\":\"between-key\",\"delivery\":\"{first_delivery}\"}}}}\n{{\"id\":5,\"method\":\"wait\"}}\n{{\"id\":6,\"method\":\"status\"}}\n{{\"id\":7,\"method\":\"inspect\",\"params\":{{\"id\":{root}}}}}").unwrap();
    input.flush().unwrap();
    let between = receive(2);
    assert_eq!(
        between["event"], "start",
        "notification-window prompt must be admitted, not BUSY: {between}"
    );
    assert_eq!(between["receipt"]["status"], "Queued");
    let after = receive(3);
    assert_eq!(after["receipt"]["status"], "Queued");
    let duplicate = receive(4);
    assert_eq!(duplicate["duplicate"], true);
    assert_eq!(duplicate["receipt"], between["receipt"]);
    let status = receive(6);
    assert_eq!(status["settled"], false);
    assert_eq!(status["active_submission_id"], root);
    assert_eq!(receive(7)["receipt"]["status"], "Running");
    if cancel && composition.is_none() && !actionable_cancel {
        writeln!(
            input,
            "{{\"id\":8,\"method\":\"abort\",\"params\":{{\"id\":{root}}}}}"
        )
        .unwrap();
        input.flush().unwrap();
        assert_eq!(receive(8)["aborting"], true);
    }
    if required_failure {
        assert_eq!(
            std::fs::read_to_string(home.join("proof.txt")).unwrap(),
            "evidence"
        );
    }
    // Ordered status+inspection responses are the barrier, not wall-clock waiting.
    assert!(
        !lines
            .iter()
            .any(|line| line["event"] == "end" || line["id"] == 5)
    );
    release_tx.send(()).unwrap();
    let mut ends = Vec::new();
    let mut waited = false;
    for _ in 0..32 {
        let line = receiver.recv_timeout(Duration::from_secs(20)).unwrap();
        if line["event"] == "end" {
            ends.push(line["id"].clone());
        }
        if line["id"] == 5 {
            assert_eq!(line["settled"], true);
            waited = true;
        }
        lines.push(line);
        if ends.len() == 3 && waited {
            break;
        }
    }
    assert_eq!(
        ends,
        [
            serde_json::json!(1),
            serde_json::json!(2),
            serde_json::json!(3)
        ]
    );
    assert!(waited);
    let terminal = lines
        .iter()
        .find(|line| line["id"] == 1 && line["event"] == "end")
        .unwrap();
    if cancel {
        assert_eq!(terminal["reason"], "Abort");
    } else if required_failure || composition.is_some() {
        assert_eq!(terminal["error"]["code"], "TURN_FAILED");
    } else {
        assert_eq!(terminal["reason"], "EndTurn");
    }
    let wait_position = lines.iter().position(|line| line["id"] == 5).unwrap();
    assert!(
        wait_position
            < lines
                .iter()
                .position(|line| line["id"] == 2 && line["event"] == "end")
                .unwrap()
    );
    assert_eq!(ready_rx.recv_timeout(Duration::from_secs(5)).unwrap(), 1);
    assert_eq!(ready_rx.recv_timeout(Duration::from_secs(5)).unwrap(), 2);
    drop(input);
    assert!(matches!(
        receiver.recv_timeout(Duration::from_secs(10)),
        Err(std::sync::mpsc::RecvTimeoutError::Disconnected)
    ));
    assert!(child.0.wait().unwrap().success());
    reader.join().unwrap();
    effect_worker.join().unwrap();
    if let Some(worker) = actionable_worker {
        worker.join().unwrap();
    }
    let requests = provider_worker.finish();
    let expected = if composition.is_some() && !cancel {
        vec!["raw-root", "raw-root", "queued-between", "queued-after"]
    } else {
        vec!["raw-root", "queued-between", "queued-after"]
    };
    assert_eq!(requests.len(), expected.len());
    for (request, expected) in requests.iter().zip(expected) {
        let last_user = request["messages"]
            .as_array()
            .unwrap()
            .iter()
            .rev()
            .find(|message| message["role"] == "user")
            .unwrap();
        assert_eq!(last_user["content"], expected);
    }
    let session_reader = smith_core::store::SessionReader::open(&session_path(&home)).unwrap();
    let limit = smith::Config::default_valid().frame_bytes_max;
    if composition.is_some() {
        assert_eq!(
            std::fs::read_to_string(home.join("A/written.txt")).unwrap(),
            "child committed"
        );
    }
    let mut cancelled_effects = 0;
    let mut settlements = Vec::new();
    let mut queue = Vec::new();
    let mut trace = Vec::new();
    let mut diagnostics = Vec::new();
    session_reader
        .scan(limit, |frame| {
            match frame {
                smith_core::frame::Frame::Settlement {
                    submission_id,
                    reason,
                    ..
                } => {
                    if actionable_cancel && serde_json::json!(submission_id) == root {
                        assert_eq!(reason, Some(smith::StopReason::Abort));
                    }
                    settlements.push(serde_json::json!(submission_id));
                    trace.push("settlement".to_string());
                }
                smith_core::frame::Frame::Known { entry }
                | smith_core::frame::Frame::NestedCommit { entry } => {
                    if let smith_core::session::EntryContent::Meta { kind, detail } =
                        smith_core::session::EntryContent::decode(&entry.content)?
                    {
                        if kind == smith_core::metadata::NOTIFICATION_QUEUE_KIND {
                            let intent: smith_core::control::NotificationAdmission =
                                detail.deserialize_as().unwrap();
                            queue.push(intent);
                        } else if kind.starts_with("lifecycle-")
                            || kind.starts_with("nested-effect-")
                        {
                            if actionable_cancel && kind == "lifecycle-effect-completion" {
                                let value = serde_json::to_value(&detail).unwrap();
                                if value["root_entry_id"] == root && value["ok"] == false {
                                    assert!(!value["output"].as_str().unwrap().is_empty());
                                    cancelled_effects += 1;
                                }
                            }
                            trace.push(kind);
                        } else if kind == "lifecycle_decision" {
                            let value = serde_json::to_value(detail).unwrap();
                            if value[0]["boundary"] == "Settled" {
                                diagnostics.push(value[1]["diagnostics"].clone());
                            }
                        }
                    }
                }
                _ => {}
            }
            Ok(())
        })
        .unwrap();
    assert_eq!(
        settlements,
        [
            root.clone(),
            between["receipt"]["submission_id"].clone(),
            after["receipt"]["submission_id"].clone()
        ]
    );
    assert_eq!(queue.len(), 2);
    assert_eq!(
        queue[0].delivery,
        if after_first {
            smith_core::agent::Delivery::AfterTurn
        } else {
            smith_core::agent::Delivery::BetweenRequests
        }
    );
    assert_eq!(
        queue[1].delivery,
        if after_first {
            smith_core::agent::Delivery::BetweenRequests
        } else {
            smith_core::agent::Delivery::AfterTurn
        }
    );
    for intent in queue {
        assert_eq!(serde_json::json!(intent.notifying_root), root);
    }
    assert_eq!(diagnostics.len(), 3);
    if !cancel && !required_failure && composition.is_none() && !after_first {
        let rendered = diagnostics[0]
            .as_array()
            .unwrap()
            .iter()
            .map(|item| {
                format!(
                    "{}:{}:{}",
                    item["component"].as_str().unwrap(),
                    item["handler"].as_str().unwrap(),
                    item["code"].as_str().unwrap()
                )
            })
            .collect::<Vec<_>>()
            .join("\n");
        insta::assert_snapshot!(rendered, @r#"
        example:notification-fault:continue:HandlerFailed
        example:notification-reopen:continue:BatchRejected
        "#);
    }
    for diagnostic in diagnostics {
        assert!(
            !diagnostic.as_array().unwrap().iter().any(|item| {
                item["component"] == "example:notification-http" && item["code"] == "HandlerFailed"
            }),
            "every settled HTTP notification must succeed: {diagnostic}"
        );
        assert_eq!(
            diagnostic
                .as_array()
                .unwrap()
                .iter()
                .filter(|item| item["code"] == "BatchRejected")
                .count(),
            1
        );
    }
    // Every terminal is strictly after all three invocation completions. HTTP
    // completion is not handler return; both records are required before ack.
    let mut pending = 0;
    let mut pending_effects = 0;
    let mut lifecycle_effects = 0;
    let mut pending_children = 0;
    let mut nested_completions = 0;
    for kind in trace {
        match kind.as_str() {
            "nested-effect-intent" => pending_children += 1,
            "nested-effect-completion" => {
                pending_children -= 1;
                nested_completions += 1;
            }
            "lifecycle-invocation-intent" => {
                assert_eq!(
                    pending_children, 0,
                    "structured children join before notification"
                );
                pending += 1;
            }
            "lifecycle-effect-intent" => pending_effects += 1,
            "lifecycle-effect-completion" => {
                pending_effects -= 1;
                lifecycle_effects += 1;
            }
            "lifecycle-invocation-completion" => {
                assert_eq!(pending_effects, 0);
                pending -= 1;
            }
            "settlement" => assert_eq!(pending, 0),
            _ => {}
        }
    }
    assert_eq!(pending, 0);
    assert_eq!(pending_effects, 0);
    if actionable_cancel {
        assert_eq!(
            cancelled_effects, 1,
            "canceled HTTP retains terminal effect evidence"
        );
        assert_eq!(
            lifecycle_effects, 6,
            "three actionable effects, including cancellation, plus three notifications"
        );
    }
    assert_eq!(pending_children, 0);
    if composition.is_some() {
        assert_eq!(
            nested_completions, 2,
            "one child plus its completed file effect"
        );
    }
    drop(session_reader);
    std::fs::remove_dir_all(home).unwrap();
}

fn session_path(home: &Path) -> std::path::PathBuf {
    std::fs::read_dir(home.join("data/smith/sessions/run"))
        .unwrap()
        .filter_map(Result::ok)
        .map(|entry| entry.path())
        .find(|path| path.extension().is_some_and(|ext| ext == "smh"))
        .unwrap()
}

#[test]
fn eval_does_not_exit_while_settled_http_notification_is_held() {
    use std::process::Stdio;
    let home = std::env::temp_dir().join(format!("slev-{:x}", smith::SessionId::new().as_u128()));
    std::fs::create_dir_all(&home).unwrap();
    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    install_settled_http(&home, &format!("http://{}", listener.local_addr().unwrap()));
    let (ready_tx, ready_rx) = std::sync::mpsc::sync_channel(1);
    let (release_tx, release_rx) = std::sync::mpsc::sync_channel(1);
    let effect_worker = std::thread::spawn(move || {
        let (mut stream, _) = listener.accept().unwrap();
        assert_eq!(body(&mut stream), serde_json::json!({}));
        ready_tx.send(()).unwrap();
        release_rx
            .recv_timeout(Duration::from_secs(10))
            .expect("explicit eval notification release");
        stream
            .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\nConnection: close\r\n\r\n{}")
            .unwrap();
    });
    let (address, provider_worker) = provider(1, false);
    let mut child = Child(
        smith(&home)
            .env("OPENAI_API_KEY", "settled-fixture-secret")
            .args([
                "eval",
                "--provider",
                "openai",
                "--model",
                "test-model",
                "--base-url",
                &format!("http://{address}/v1"),
                "raw-root",
            ])
            .stdout(Stdio::piped())
            .stderr(Stdio::piped())
            .spawn()
            .unwrap(),
    );
    let mut stdout = child.0.stdout.take().unwrap();
    let (done_tx, done_rx) = std::sync::mpsc::sync_channel(1);
    let reader = std::thread::spawn(move || {
        let mut output = Vec::new();
        stdout.read_to_end(&mut output).unwrap();
        let _sent = done_tx.send(output);
    });
    ready_rx.recv_timeout(Duration::from_secs(20)).unwrap();
    assert!(
        child.0.try_wait().unwrap().is_none(),
        "eval must retain joined notification work"
    );
    assert!(matches!(
        done_rx.try_recv(),
        Err(std::sync::mpsc::TryRecvError::Empty)
    ));
    let path = session_path(&home);
    let session_reader = smith_core::store::SessionReader::open(&path).unwrap();
    let limit = smith::Config::default_valid().frame_bytes_max;
    let mut settlements = 0;
    session_reader
        .scan(limit, |frame| {
            if matches!(frame, smith_core::frame::Frame::Settlement { .. }) {
                settlements += 1;
            }
            Ok(())
        })
        .unwrap();
    assert_eq!(
        settlements, 0,
        "HTTP readiness precedes terminal persistence"
    );
    release_tx.send(()).unwrap();
    assert_eq!(
        done_rx.recv_timeout(Duration::from_secs(20)).unwrap(),
        b"first\n"
    );
    assert!(child.0.wait().unwrap().success());
    reader.join().unwrap();
    effect_worker.join().unwrap();
    assert_eq!(provider_worker.finish().len(), 1);
}