supercode-cli 0.4.8

//! Real-binary regressions for preset capability activation. A preset is not
//! merely catalog metadata: with the experimental registry enabled from the
//! trusted layer, its runtime gates must match the resolved capability set.

use std::io::{Read, Write};
use std::net::TcpListener;
use std::path::{Path, PathBuf};
use std::process::{Command, Output, Stdio};
use std::time::Duration;

use supercode::reduce::{ReductionKind, ReductionLog};
use supercode::Session;

fn bin() -> PathBuf {
    PathBuf::from(env!("CARGO_BIN_EXE_supercode"))
}

fn fresh_dir(tag: &str) -> PathBuf {
    let nanos = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_nanos();
    let dir = std::env::temp_dir().join(format!(
        "supercode-preset-capability-{tag}-{}-{nanos}",
        std::process::id()
    ));
    std::fs::create_dir_all(&dir).unwrap();
    dir
}

fn write_preset(home: &Path, preset: &str) {
    std::fs::write(
        home.join("config.toml"),
        format!(
            "schema_version = 1\nextends = \"{preset}\"\n\n[experimental]\nmodule_registry = true\n"
        ),
    )
    .unwrap();
}

fn write_pi_preset_with_core_narrowing(home: &Path) {
    std::fs::write(
        home.join("config.toml"),
        "schema_version = 1\nextends = \"pi-core\"\n\
         \n[experimental]\nmodule_registry = true\n\
         \n[core.tools]\nenabled = [\"read_file\"]\n\
         \n[core.skills]\nenabled = false\n\
         \n[core.prompts]\nprobe = \"preset narrowing probe {args}\"\n",
    )
    .unwrap();
}

/// Genuine Pi v3 wire shape with six retry-style bash results carrying the
/// same non-trivial output. The first result stays canonical, the next two
/// are eligible for TR-2, and the newest three remain protected.
fn write_pi_duplicate_fixture(dir: &Path) -> (PathBuf, String) {
    let failure = format!(
        "running 1 test\ntest retry ... FAILED\n\n{}test result: FAILED\n",
        "assertion failed: left == right\n".repeat(60)
    );
    assert!(failure.len() > 256 && failure.len() < 8192);

    let mut lines = vec![serde_json::json!({
        "type": "session",
        "version": 3,
        "id": "019f413c-95eb-7b14-9dc7-8a133978e39e",
        "timestamp": "2026-07-08T10:18:37.419Z",
        "cwd": dir,
    })
    .to_string()];
    let mut parent: Option<String> = None;
    let user_id = "pi-user-0".to_string();
    lines.push(
        serde_json::json!({
            "type": "message",
            "id": user_id,
            "parentId": parent,
            "timestamp": "2026-07-08T10:18:37.420Z",
            "message": {
                "role": "user",
                "content": [{"type": "text", "text": "Why does this test keep failing?"}],
                "timestamp": 1783505917420_u64,
            }
        })
        .to_string(),
    );
    parent = Some("pi-user-0".to_string());
    for i in 0..6 {
        let assistant_id = format!("pi-assistant-{i}");
        let tool_id = format!("tool:1783505917420:retry{i}");
        lines.push(
            serde_json::json!({
                "type": "message",
                "id": assistant_id,
                "parentId": parent,
                "timestamp": "2026-07-08T10:18:37.421Z",
                "message": {
                    "role": "assistant",
                    "content": [{
                        "type": "toolCall", "id": tool_id,
                        "name": "bash", "arguments": {"command": "cargo test retry"}
                    }],
                    "api": "anthropic-messages", "provider": "anthropic",
                    "model": "claude-opus-4-8", "stopReason": "toolUse",
                    "timestamp": 1783505917421_u64,
                }
            })
            .to_string(),
        );
        let result_id = format!("pi-result-{i}");
        lines.push(
            serde_json::json!({
                "type": "message",
                "id": result_id,
                "parentId": assistant_id,
                "timestamp": "2026-07-08T10:18:37.422Z",
                "message": {
                    "role": "toolResult", "toolCallId": tool_id,
                    "toolName": "bash",
                    "content": [{"type": "text", "text": failure}],
                    "isError": false, "timestamp": 1783505917422_u64,
                }
            })
            .to_string(),
        );
        parent = Some(result_id);
    }
    let path = dir.join("pi-duplicate-retries.jsonl");
    std::fs::write(&path, lines.join("\n") + "\n").unwrap();
    (path, failure)
}

fn reduction_log(home: &Path) -> ReductionLog {
    let log_path = std::fs::read_dir(home.join("sessions"))
        .unwrap()
        .flatten()
        .map(|entry| entry.path())
        .find(|path| path.to_string_lossy().ends_with(".reduction.json"))
        .expect("resume must persist a reduction log before provider failure");
    serde_json::from_str(&std::fs::read_to_string(log_path).unwrap()).unwrap()
}

fn command(home: &Path, cwd: &Path) -> Command {
    let mut cmd = Command::new(bin());
    cmd.current_dir(cwd)
        .env("SUPERCODE_HOME", home)
        .env("HOME", home)
        .env_remove("OPENROUTER_API_KEY")
        .env_remove("OPENAI_API_KEY")
        .env_remove("ANTHROPIC_API_KEY")
        .env_remove("NO_COLOR")
        .stdin(Stdio::null())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());
    cmd
}

fn stderr(out: &Output) -> String {
    String::from_utf8_lossy(&out.stderr).into_owned()
}

fn spawn_capture_stub() -> (
    std::net::SocketAddr,
    std::thread::JoinHandle<serde_json::Value>,
) {
    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    let addr = listener.local_addr().unwrap();
    let handle = std::thread::spawn(move || {
        let (mut socket, _) = listener.accept().unwrap();
        socket
            .set_read_timeout(Some(Duration::from_secs(5)))
            .unwrap();
        let mut request = Vec::new();
        let mut chunk = [0u8; 8192];
        let header_end = loop {
            let n = socket.read(&mut chunk).unwrap();
            request.extend_from_slice(&chunk[..n]);
            if let Some(pos) = request.windows(4).position(|w| w == b"\r\n\r\n") {
                break pos + 4;
            }
        };
        let headers = String::from_utf8_lossy(&request[..header_end]);
        let content_len: usize = headers
            .lines()
            .find_map(|line| {
                line.to_ascii_lowercase()
                    .strip_prefix("content-length:")
                    .and_then(|v| v.trim().parse().ok())
            })
            .unwrap();
        while request.len() - header_end < content_len {
            let n = socket.read(&mut chunk).unwrap();
            request.extend_from_slice(&chunk[..n]);
        }
        let body: serde_json::Value =
            serde_json::from_slice(&request[header_end..header_end + content_len]).unwrap();
        let sse = "data: {\"choices\":[{\"delta\":{\"content\":\"ok\"}}]}\n\ndata: [DONE]\n\n";
        write!(
            socket,
            "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{sse}",
            sse.len()
        )
        .unwrap();
        body
    });
    (addr, handle)
}

fn spawn_span_summary_stub() -> (
    std::net::SocketAddr,
    std::thread::JoinHandle<Vec<serde_json::Value>>,
) {
    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    listener.set_nonblocking(true).unwrap();
    let addr = listener.local_addr().unwrap();
    let handle = std::thread::spawn(move || {
        // This fixture sends six multi-megabyte loopback requests through a
        // freshly spawned debug binary. Keep the behavioral bound finite,
        // but allow loaded builders enough time to complete the same fixed
        // request sequence instead of failing on host throughput alone.
        let deadline = std::time::Instant::now() + Duration::from_secs(30);
        let mut requests = Vec::new();
        let mut main_requests = 0usize;
        let mut summary_requests = 0usize;
        while main_requests < 5 || summary_requests < 1 {
            let (mut socket, _) = match listener.accept() {
                Ok(pair) => pair,
                Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                    assert!(
                        std::time::Instant::now() < deadline,
                        "timed out waiting for five main requests plus one summary request; got {requests:?}"
                    );
                    std::thread::sleep(Duration::from_millis(10));
                    continue;
                }
                Err(e) => panic!("accept failed: {e}"),
            };
            socket.set_nonblocking(false).unwrap();
            socket
                .set_read_timeout(Some(Duration::from_secs(5)))
                .unwrap();
            let mut request = Vec::new();
            let mut chunk = [0u8; 8192];
            let header_end = loop {
                let n = socket.read(&mut chunk).unwrap();
                request.extend_from_slice(&chunk[..n]);
                if let Some(pos) = request.windows(4).position(|w| w == b"\r\n\r\n") {
                    break pos + 4;
                }
            };
            let headers = String::from_utf8_lossy(&request[..header_end]);
            let content_len: usize = headers
                .lines()
                .find_map(|line| {
                    line.to_ascii_lowercase()
                        .strip_prefix("content-length:")
                        .and_then(|v| v.trim().parse().ok())
                })
                .unwrap();
            while request.len() - header_end < content_len {
                let n = socket.read(&mut chunk).unwrap();
                request.extend_from_slice(&chunk[..n]);
            }
            let body: serde_json::Value =
                serde_json::from_slice(&request[header_end..header_end + content_len]).unwrap();
            let model = body["model"].as_str().unwrap();
            let response = if model == "anthropic/claude-haiku-4-5" {
                summary_requests += 1;
                "data: {\"choices\":[{\"delta\":{\"content\":\"cheap-model span summary\"}}]}\n\ndata: [DONE]\n\n".to_string()
            } else if main_requests < 4 {
                main_requests += 1;
                let call_id = format!("call-{main_requests}");
                let arguments =
                    serde_json::json!({"command": format!("echo loop-{main_requests}")})
                        .to_string();
                format!(
                    "data: {{\"choices\":[{{\"delta\":{{\"tool_calls\":[{{\"index\":0,\"id\":\"{call_id}\",\"function\":{{\"name\":\"bash\",\"arguments\":{}}}}}]}}}}]}}\n\ndata: [DONE]\n\n",
                    serde_json::to_string(&arguments).unwrap()
                )
            } else {
                main_requests += 1;
                "data: {\"choices\":[{\"delta\":{\"content\":\"done\"}}]}\n\ndata: [DONE]\n\n"
                    .to_string()
            };
            requests.push(body);
            write!(
                socket,
                "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{response}",
                response.len()
            )
            .unwrap();
        }
        requests
    });
    (addr, handle)
}

#[test]
fn trusted_pi_core_preset_enables_server_but_project_preset_cannot() {
    let trusted_home = fresh_dir("pi-trusted-home");
    let clean_project = fresh_dir("pi-clean-project");
    write_preset(&trusted_home, "pi-core");

    let trusted = command(&trusted_home, &clean_project)
        .args([
            "--api-key",
            "x",
            "serve",
            "--no-tmux",
            "--bind",
            "not-an-address",
        ])
        .output()
        .unwrap();
    assert!(!trusted.status.success());
    let trusted_err = stderr(&trusted);
    assert!(
        !trusted_err.contains("requires [capabilities.server] enabled"),
        "trusted pi-core must pass the capability gate: {trusted_err}"
    );

    let registry_home = fresh_dir("registry-only-home");
    std::fs::write(
        registry_home.join("config.toml"),
        "schema_version = 1\n[experimental]\nmodule_registry = true\n",
    )
    .unwrap();
    let hostile_project = fresh_dir("pi-hostile-project");
    std::fs::write(
        hostile_project.join(".supercode.toml"),
        "schema_version = 1\nextends = \"pi-core\"\n",
    )
    .unwrap();
    let hostile = command(&registry_home, &hostile_project)
        .args([
            "--api-key",
            "x",
            "serve",
            "--no-tmux",
            "--bind",
            "not-an-address",
        ])
        .output()
        .unwrap();
    assert!(!hostile.status.success());
    assert!(
        stderr(&hostile).contains("requires [capabilities.server] enabled"),
        "an untrusted project preset must not reintroduce the server module"
    );
}

#[test]
fn trusted_cc_parity_preset_enables_checkpoint_cli() {
    let home = fresh_dir("cc-home");
    let project = fresh_dir("cc-project");
    write_preset(&home, "cc-parity");

    let out = command(&home, &project)
        .args(["checkpoint", "list", "--json"])
        .output()
        .unwrap();
    assert!(
        out.status.success(),
        "checkpoint list failed: {}",
        stderr(&out)
    );
    assert_eq!(
        serde_json::from_slice::<serde_json::Value>(&out.stdout).unwrap(),
        serde_json::json!([])
    );
}

#[test]
fn trusted_token_saver_preset_enters_reduced_resume_and_writes_sidecar() {
    let home = fresh_dir("token-home");
    let project = fresh_dir("token-project");
    write_preset(&home, "token-saver");
    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("../harness/tests/fixtures/pi_real_corpus_tool_call.jsonl");

    let (addr, handle) = spawn_capture_stub();
    let base_url = format!("http://{addr}");
    let out = command(&home, &project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            &base_url,
            "--quiet",
            "resume",
        ])
        .arg(&fixture)
        .arg("preset reduction probe")
        .output()
        .unwrap();
    assert!(
        out.status.success(),
        "reduced resume failed: {}",
        stderr(&out)
    );
    let _request = handle.join().unwrap();

    let sessions = home.join("sessions");
    let has_sidecar = std::fs::read_dir(&sessions)
        .unwrap()
        .flatten()
        .any(|entry| entry.path().to_string_lossy().ends_with(".sidecar.jsonl"));
    assert!(
        has_sidecar,
        "token-saver must enter reduced mode and create its full-fidelity sidecar"
    );
}

#[test]
fn trusted_token_saver_preset_materializes_its_minimal_schema_tier() {
    let home = fresh_dir("token-schema-home");
    let project = fresh_dir("token-schema-project");
    write_preset(&home, "token-saver");

    let capture = |schema_tier: Option<&str>| {
        let (addr, handle) = spawn_capture_stub();
        let mut cmd = command(&home, &project);
        let base_url = format!("http://{addr}");
        cmd.args([
            "--api-key",
            "x",
            "--base-url",
            &base_url,
            "--quiet",
            "--no-project-context",
        ]);
        if let Some(tier) = schema_tier {
            cmd.args(["--schema-tier", tier]);
        }
        let out = cmd.args(["run", "schema probe"]).output().unwrap();
        assert!(out.status.success(), "request failed: {}", stderr(&out));
        handle.join().unwrap()
    };

    let preset_only = capture(None);
    let explicit = capture(Some("minimal"));
    let full_override = capture(Some("full"));
    assert_eq!(
        preset_only["tools"], explicit["tools"],
        "token-saver's schema tier must reach the exact request surface without a duplicate flag"
    );
    assert_ne!(
        preset_only["tools"], full_override["tools"],
        "an explicit CLI schema tier must still override the preset"
    );
}

fn request_tool_names(request: &serde_json::Value) -> Vec<&str> {
    request["tools"]
        .as_array()
        .unwrap()
        .iter()
        .map(|tool| tool["function"]["name"].as_str().unwrap())
        .collect()
}

fn request_system_text(request: &serde_json::Value) -> &str {
    request["messages"]
        .as_array()
        .unwrap()
        .iter()
        .find(|message| message["role"] == "system")
        .and_then(|message| message["content"].as_str())
        .unwrap()
}

fn capture_run(home: &Path, project: &Path) -> serde_json::Value {
    let (addr, handle) = spawn_capture_stub();
    let base_url = format!("http://{addr}");
    let out = command(home, project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            &base_url,
            "--quiet",
            "--no-project-context",
            "run",
            "preset narrowing probe",
        ])
        .output()
        .unwrap();
    assert!(out.status.success(), "request failed: {}", stderr(&out));
    handle.join().unwrap()
}

#[test]
fn trusted_core_narrowing_overrides_pi_preset_on_the_real_request() {
    let home = fresh_dir("pi-trusted-narrow-home");
    let project = fresh_dir("pi-trusted-narrow-project");
    write_pi_preset_with_core_narrowing(&home);

    let request = capture_run(&home, &project);
    let tools = request_tool_names(&request);
    assert!(tools.contains(&"read_file"));
    for forbidden in ["bash", "edit_file", "write_file"] {
        assert!(
            !tools.contains(&forbidden),
            "trusted [core.tools] narrowing must override pi-core: {tools:?}"
        );
    }
    assert!(
        !request_system_text(&request).contains("# Skills"),
        "trusted core.skills=false must suppress pi-core's skills section"
    );
}

#[test]
fn project_core_narrowing_overrides_pi_preset_on_the_real_request() {
    let home = fresh_dir("pi-project-narrow-home");
    let project = fresh_dir("pi-project-narrow-project");
    write_preset(&home, "pi-core");
    std::fs::write(
        project.join(".supercode.toml"),
        "schema_version = 1\n\
         [core.tools]\nenabled = [\"read_file\"]\n\
         [core.skills]\nenabled = false\n",
    )
    .unwrap();

    let request = capture_run(&home, &project);
    let tools = request_tool_names(&request);
    assert!(tools.contains(&"read_file"));
    for forbidden in ["bash", "edit_file", "write_file"] {
        assert!(
            !tools.contains(&forbidden),
            "safe project narrowing must override pi-core: {tools:?}"
        );
    }
}

#[test]
fn invalid_project_narrowing_fails_closed_before_provider_connection() {
    let home = fresh_dir("pi-project-invalid-home");
    let project = fresh_dir("pi-project-invalid-project");
    write_preset(&home, "pi-core");
    std::fs::write(
        project.join(".supercode.toml"),
        "schema_version = 1\n[core.tools]\nenabled = []\n",
    )
    .unwrap();

    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    listener.set_nonblocking(true).unwrap();
    let base_url = format!("http://{}", listener.local_addr().unwrap());
    let out = command(&home, &project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            &base_url,
            "--quiet",
            "run",
            "must fail closed",
        ])
        .output()
        .unwrap();
    assert!(!out.status.success());
    let err = stderr(&out);
    assert!(
        err.contains("module_registry configuration is invalid") && err.contains("core.skills"),
        "the dependency error must be explicit: {err}"
    );
    assert!(
        matches!(listener.accept(), Err(e) if e.kind() == std::io::ErrorKind::WouldBlock),
        "invalid narrowing must fail before any provider request"
    );
}

#[test]
fn token_saver_stale_read_gate_reaches_the_live_reduction_policy() {
    let home = fresh_dir("token-stale-home");
    let project = fresh_dir("token-stale-project");
    write_preset(&home, "token-saver");
    let content = "stable file contents for stale-read preset probe\n";
    let data_path = project.join("data.txt");
    std::fs::write(&data_path, content).unwrap();

    let assistant_call = |id: &str,
                          parent: &str,
                          call_id: &str,
                          name: &str,
                          arguments: serde_json::Value| {
        serde_json::json!({
            "type": "message", "id": id, "parentId": parent,
            "timestamp": "2026-07-13T03:30:00.000Z",
            "message": {
                "role": "assistant",
                "content": [{"type": "toolCall", "id": call_id, "name": name, "arguments": arguments}],
                "api": "openai-responses", "provider": "openai", "model": "probe",
                "stopReason": "toolUse", "timestamp": 1783913400000_u64
            }
        })
    };
    let tool_result = |id: &str, parent: &str, call_id: &str, name: &str, output: &str| {
        serde_json::json!({
            "type": "message", "id": id, "parentId": parent,
            "timestamp": "2026-07-13T03:30:00.000Z",
            "message": {
                "role": "toolResult", "toolCallId": call_id, "toolName": name,
                "content": [{"type": "text", "text": output}], "isError": false,
                "timestamp": 1783913400000_u64
            }
        })
    };
    let records = vec![
        serde_json::json!({
            "type": "session", "version": 3, "id": "token-stale-probe",
            "timestamp": "2026-07-13T03:30:00.000Z", "cwd": project
        }),
        serde_json::json!({
            "type": "message", "id": "m1", "parentId": null,
            "timestamp": "2026-07-13T03:30:00.000Z",
            "message": {"role": "user", "content": [{"type": "text", "text": "read it"}], "timestamp": 1783913400000_u64}
        }),
        assistant_call(
            "m2",
            "m1",
            "read-1",
            "read_file",
            serde_json::json!({"path": data_path}),
        ),
        tool_result("m3", "m2", "read-1", "read_file", content),
        assistant_call(
            "m4",
            "m3",
            "bash-1",
            "bash",
            serde_json::json!({"command": "echo one"}),
        ),
        tool_result("m5", "m4", "bash-1", "bash", "one"),
        assistant_call(
            "m6",
            "m5",
            "bash-2",
            "bash",
            serde_json::json!({"command": "echo two"}),
        ),
        tool_result("m7", "m6", "bash-2", "bash", "two"),
        assistant_call(
            "m8",
            "m7",
            "bash-3",
            "bash",
            serde_json::json!({"command": "echo three"}),
        ),
        tool_result("m9", "m8", "bash-3", "bash", "three"),
    ];
    let session_path = project.join("session.jsonl");
    std::fs::write(
        &session_path,
        records
            .iter()
            .map(serde_json::Value::to_string)
            .collect::<Vec<_>>()
            .join("\n"),
    )
    .unwrap();

    let (addr, handle) = spawn_capture_stub();
    let base_url = format!("http://{addr}");
    let out = command(&home, &project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            &base_url,
            "--quiet",
            "resume",
        ])
        .arg(&session_path)
        .arg("continue")
        .output()
        .unwrap();
    assert!(out.status.success(), "resume failed: {}", stderr(&out));
    let request = handle.join().unwrap();
    assert!(
        !request.to_string().contains(content.trim()),
        "token-saver must elide a verified unchanged old read from the provider request"
    );

    let log_path = std::fs::read_dir(home.join("sessions"))
        .unwrap()
        .flatten()
        .map(|entry| entry.path())
        .find(|path| path.to_string_lossy().ends_with(".reduction.json"))
        .unwrap();
    let log: ReductionLog =
        serde_json::from_str(&std::fs::read_to_string(log_path).unwrap()).unwrap();
    assert!(
        log.reductions
            .iter()
            .any(|r| matches!(r.kind, ReductionKind::FileReadElided { .. })),
        "the persisted audit log must name FileReadElided: {log:?}"
    );

    std::fs::write(
        project.join(".supercode.toml"),
        "schema_version = 1\n[capabilities.reduction]\nstale_reads = false\n",
    )
    .unwrap();
    let (addr, handle) = spawn_capture_stub();
    let base_url = format!("http://{addr}");
    let out = command(&home, &project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            &base_url,
            "--quiet",
            "resume",
        ])
        .arg(&session_path)
        .arg("continue with override")
        .output()
        .unwrap();
    assert!(
        out.status.success(),
        "override resume failed: {}",
        stderr(&out)
    );
    assert!(
        handle.join().unwrap().to_string().contains(content.trim()),
        "a direct safe project override must disable the preset gate"
    );
}

#[test]
fn project_duplicates_false_disables_token_saver_dedup_on_real_pi_session() {
    let enabled_home = fresh_dir("duplicates-enabled-home");
    let enabled_project = fresh_dir("duplicates-enabled-project");
    write_preset(&enabled_home, "token-saver");
    let (enabled_fixture, failure) = write_pi_duplicate_fixture(&enabled_project);
    let enabled = command(&enabled_home, &enabled_project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            "http://127.0.0.1:1",
            "--quiet",
            "resume",
        ])
        .arg(&enabled_fixture)
        .arg("continue")
        .output()
        .unwrap();
    assert!(
        !enabled.status.success(),
        "offline provider must be unreachable"
    );
    let enabled_log = reduction_log(&enabled_home);
    assert_eq!(
        enabled_log
            .reductions
            .iter()
            .filter(|row| matches!(row.kind, ReductionKind::DuplicateOutput { .. }))
            .count(),
        2,
        "token-saver must deduplicate the two eligible repeated outputs: {enabled_log:?}"
    );

    let disabled_home = fresh_dir("duplicates-disabled-home");
    let disabled_project = fresh_dir("duplicates-disabled-project");
    write_preset(&disabled_home, "token-saver");
    std::fs::write(
        disabled_project.join(".supercode.toml"),
        "schema_version = 1\n[capabilities.reduction]\nduplicates = false\n",
    )
    .unwrap();
    let (disabled_fixture, _) = write_pi_duplicate_fixture(&disabled_project);
    let disabled = command(&disabled_home, &disabled_project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            "http://127.0.0.1:1",
            "--quiet",
            "resume",
        ])
        .arg(&disabled_fixture)
        .arg("continue")
        .output()
        .unwrap();
    assert!(
        !disabled.status.success(),
        "offline provider must be unreachable"
    );
    let disabled_log = reduction_log(&disabled_home);
    assert!(
        disabled_log
            .reductions
            .iter()
            .all(|row| !matches!(row.kind, ReductionKind::DuplicateOutput { .. })),
        "duplicates=false must preserve repeated results in the working view: {disabled_log:?}"
    );

    let sidecar_path = std::fs::read_dir(disabled_home.join("sessions"))
        .unwrap()
        .flatten()
        .map(|entry| entry.path())
        .find(|path| path.to_string_lossy().ends_with(".sidecar.jsonl"))
        .unwrap();
    let sidecar = std::fs::read_to_string(sidecar_path).unwrap();
    let sidecar = Session::from_sidecar_str(&sidecar).unwrap();
    assert_eq!(
        sidecar
            .messages
            .iter()
            .filter(|message| message.content.as_deref() == Some(failure.as_str()))
            .count(),
        6,
        "the full sidecar remains byte-complete when the optional view pass is disabled"
    );
}

#[test]
fn token_saver_installs_small_model_span_summarizer_on_real_continuation() {
    let home = fresh_dir("token-summary-home");
    let project = fresh_dir("token-summary-project");
    write_preset(&home, "token-saver");
    let fixture = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("../harness/tests/fixtures/pi_real_corpus_tool_call.jsonl");
    let prompt = format!("pressure-summary-probe-{}", "x".repeat(3_000));

    let (addr, handle) = spawn_span_summary_stub();
    let base_url = format!("http://{addr}");
    let out = command(&home, &project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            &base_url,
            "--quiet",
            "resume",
        ])
        .arg(&fixture)
        .arg(prompt)
        .output()
        .unwrap();
    assert!(out.status.success(), "resume failed: {}", stderr(&out));
    let requests = handle.join().unwrap();
    let summary_request = requests
        .iter()
        .find(|request| request["model"] == "anthropic/claude-haiku-4-5")
        .expect("token-saver must route the span side-call to its small model");
    assert!(
        summary_request
            .to_string()
            .contains("pressure-summary-probe"),
        "the summary request must contain the actual cleared span"
    );

    let log_path = std::fs::read_dir(home.join("sessions"))
        .unwrap()
        .flatten()
        .map(|entry| entry.path())
        .find(|path| path.to_string_lossy().ends_with(".reduction.json"))
        .unwrap();
    let log: ReductionLog =
        serde_json::from_str(&std::fs::read_to_string(log_path).unwrap()).unwrap();
    let summary = log.reductions.iter().find_map(|r| match &r.kind {
        ReductionKind::TurnsCleared {
            summary: Some(summary),
            ..
        } => Some(summary),
        _ => None,
    });
    let summary = summary.expect("TurnsCleared must persist summary audit metadata");
    assert_eq!(summary.model_id, "anthropic/claude-haiku-4-5");
    assert!(log
        .reductions
        .iter()
        .any(|r| r.placeholder.contains("cheap-model span summary")));
}

#[test]
fn token_saver_summarizes_initial_context_pressure_clear_before_main_request() {
    let home = fresh_dir("token-initial-summary-home");
    let project = fresh_dir("token-initial-summary-project");
    write_preset(&home, "token-saver");
    let mut records = vec![serde_json::json!({
        "type": "session", "version": 3, "id": "initial-summary-pressure",
        "timestamp": "2026-07-13T04:00:00.000Z", "cwd": project
    })];
    let payload = format!("initial-pressure-marker-{}", "z".repeat(15_000));
    let mut parent: Option<String> = None;
    for i in 0..80 {
        let id = format!("pressure-{i}");
        let role = if i % 2 == 0 { "user" } else { "assistant" };
        let mut message = serde_json::json!({
            "role": role,
            "content": [{"type": "text", "text": format!("{i}:{payload}")}],
            "timestamp": 1783915200000_u64 + i as u64
        });
        if role == "assistant" {
            message["api"] = serde_json::json!("openai-responses");
            message["provider"] = serde_json::json!("openai");
            message["model"] = serde_json::json!("probe");
            message["stopReason"] = serde_json::json!("stop");
        }
        records.push(serde_json::json!({
            "type": "message", "id": id, "parentId": parent,
            "timestamp": "2026-07-13T04:00:00.000Z", "message": message
        }));
        parent = Some(id);
    }
    let fixture = project.join("pressure.jsonl");
    std::fs::write(
        &fixture,
        records
            .iter()
            .map(serde_json::Value::to_string)
            .collect::<Vec<_>>()
            .join("\n"),
    )
    .unwrap();

    let (addr, handle) = spawn_span_summary_stub();
    let base_url = format!("http://{addr}");
    let out = command(&home, &project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            &base_url,
            "--model",
            "pressure-probe",
            "--quiet",
            "resume",
        ])
        .arg(&fixture)
        .arg("continue")
        .output()
        .unwrap();
    assert!(
        out.status.success(),
        "pressure resume failed: {}",
        stderr(&out)
    );
    let requests = handle.join().unwrap();
    assert_eq!(
        requests[0]["model"], "anthropic/claude-haiku-4-5",
        "initial A10 must be summarized before the first main-model request"
    );
    assert!(requests[0].to_string().contains("initial-pressure-marker"));

    let log_path = std::fs::read_dir(home.join("sessions"))
        .unwrap()
        .flatten()
        .map(|entry| entry.path())
        .find(|path| path.to_string_lossy().ends_with(".reduction.json"))
        .unwrap();
    let log: ReductionLog =
        serde_json::from_str(&std::fs::read_to_string(log_path).unwrap()).unwrap();
    assert!(log.reductions.iter().any(|r| matches!(
        r.kind,
        ReductionKind::TurnsCleared {
            summary: Some(_),
            ..
        }
    )));
}

#[test]
fn unrescuable_token_saver_import_makes_no_summary_or_main_connection() {
    let home = fresh_dir("token-unrescuable-home");
    let project = fresh_dir("token-unrescuable-project");
    write_preset(&home, "token-saver");
    let huge = "u".repeat(600_000);
    let mut records = vec![serde_json::json!({
        "type": "session", "version": 3, "id": "unrescuable-summary-pressure",
        "timestamp": "2026-07-13T04:00:00.000Z", "cwd": project
    })];
    let mut parent: Option<String> = None;
    for i in 0..8 {
        let id = format!("unrescuable-{i}");
        let role = if i % 2 == 0 { "user" } else { "assistant" };
        let text = if i >= 6 {
            format!("protected-tail-{i}-{huge}")
        } else {
            format!("clearable-{i}")
        };
        let mut message = serde_json::json!({
            "role": role, "content": [{"type": "text", "text": text}],
            "timestamp": 1783915200000_u64 + i as u64
        });
        if role == "assistant" {
            message["api"] = serde_json::json!("openai-responses");
            message["provider"] = serde_json::json!("openai");
            message["model"] = serde_json::json!("probe");
            message["stopReason"] = serde_json::json!("stop");
        }
        records.push(serde_json::json!({
            "type": "message", "id": id, "parentId": parent,
            "timestamp": "2026-07-13T04:00:00.000Z", "message": message
        }));
        parent = Some(id);
    }
    let fixture = project.join("unrescuable.jsonl");
    std::fs::write(
        &fixture,
        records
            .iter()
            .map(serde_json::Value::to_string)
            .collect::<Vec<_>>()
            .join("\n"),
    )
    .unwrap();

    let listener = TcpListener::bind("127.0.0.1:0").unwrap();
    listener.set_nonblocking(true).unwrap();
    let base_url = format!("http://{}", listener.local_addr().unwrap());
    let out = command(&home, &project)
        .args([
            "--api-key",
            "x",
            "--base-url",
            &base_url,
            "--model",
            "pressure-probe",
            "--quiet",
            "resume",
        ])
        .arg(&fixture)
        .arg("must refuse locally")
        .output()
        .unwrap();
    assert!(!out.status.success());
    let err = stderr(&out);
    assert!(
        err.contains("cannot reduce below context limit"),
        "unexpected refusal: {err}"
    );
    assert!(
        matches!(listener.accept(), Err(e) if e.kind() == std::io::ErrorKind::WouldBlock),
        "an unrescuable import must make neither a summary nor main-model connection"
    );
    assert!(
        !home.join("sessions").exists(),
        "refusal must occur before minting any reduced-session family"
    );
}