agent-block 0.35.0

mod common;

use agent_block_testkit::server::MockLlm;
use agent_block_testkit::shapes::{anthropic, openai};
use predicates::prelude::*;
use serde_json::json;
use std::sync::atomic::Ordering;
use tempfile::tempdir;

/// Pick (path_a, path_b) from the request-extracted paths, with basename
/// fallbacks (fallbacks should not be hit in normal runs).
fn two_paths(paths: &[String]) -> (String, String) {
    match paths.len() {
        0 => ("file_a.lua".to_string(), "file_b.lua".to_string()),
        1 => (paths[0].clone(), "file_b.lua".to_string()),
        _ => (paths[0].clone(), paths[1].clone()),
    }
}

/// Path-header SEARCH/REPLACE text patching both files (a-old→a-new, b-old→b-new).
fn sr_text_both(path_a: &str, path_b: &str) -> String {
    format!(
        "<<< path={path_a} >>>\n<<<<<<< SEARCH\nprint(\"a-old\")\n=======\nprint(\"a-new\")\n>>>>>>> REPLACE\n\n<<< path={path_b} >>>\n<<<<<<< SEARCH\nprint(\"b-old\")\n=======\nprint(\"b-new\")\n>>>>>>> REPLACE"
    )
}

/// Verifies compile_loop in diff mode (edit_mode="diff") with the Anthropic provider.
///
/// Scenario: 2 iterations.
///   - Iter 1: mock returns a SEARCH/REPLACE block with a wrong SEARCH text.
///     apply_blocks detects the mismatch → failure feedback sent back → 2nd LLM call.
///   - Iter 2: mock returns a correct SEARCH/REPLACE block (exact match of initial file).
///     apply_blocks succeeds → file patched → mock_runner detects "world" in output → ok=true.
///
/// Validates that:
///   - The diff mode parse/apply pipeline is wired correctly.
///   - A SEARCH mismatch triggers a retry (not a silent skip).
///   - The runner is invoked after a successful apply.
///   - The loop converges on the second LLM call.
///
/// No `#[ignore]` — runs under plain `cargo test` with no API keys.
#[tokio::test]
async fn compile_loop_diff_anthropic_mock_iterates_until_pass() {
    let (base_url, call_count, ct) =
        common::compile_loop_diff_anthropic_mock::spawn_compile_loop_diff_anthropic_mock_server()
            .await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let url_clone = base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args([
                "-s",
                &common::fixture("compile_loop_diff_anthropic_mock.lua"),
            ])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_DIFF_MOCK_PASS"));
    })
    .await
    .expect("subprocess assertion task should not panic");

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        2,
        "expected exactly 2 HTTP calls to the diff anthropic mock (iter1: apply-fail, iter2: pass)"
    );
    ct.cancel();
}

/// Verifies that compile_loop iterates exactly twice: once returning broken code
/// (mock_runner fails) and once returning fixed code (mock_runner passes).
///
/// Spawns an in-process OpenAI mock that returns a broken Lua fenced block on
/// the first HTTP request and a fixed Lua fenced block on the second.
/// The Lua fixture's `mock_runner` closure enforces strict fail-then-pass
/// sequencing via a `call_count` upvalue (Crux #2).
///
/// No `#[ignore]` — runs under plain `cargo test` with no API keys (Crux #3).
/// `OPENAI_API_KEY` is not set; `api_key="dummy"` is injected as a literal.
#[tokio::test]
async fn compile_loop_openai_mock_iterates_until_pass() {
    let (base_url, call_count, ct) =
        common::compile_loop_openai_mock::spawn_compile_loop_openai_mock_server().await;
    // Give the server a moment to start accepting connections before the subprocess runs.
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let url_clone = base_url.clone();
    tokio::task::spawn_blocking(move || {
        // Safety: tempdir() panics only on OS-level temp directory failure,
        // which is a fatal test infra condition, not a recoverable error.
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args(["-s", &common::fixture("compile_loop_openai_mock.lua")])
            .env("OPENAI_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_MOCK_PASS"));
    })
    .await
    // Safety: spawn_blocking does not panic on its own; any panic would come from
    // the assertion block above failing, which we want to propagate.
    .expect("subprocess assertion task should not panic");

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        2,
        "expected exactly 2 HTTP calls to the mock (turn 1: broken, turn 2: fixed)"
    );
    ct.cancel();
}

/// Verifies that compile_loop iterates exactly twice with the Anthropic provider:
/// once returning broken code (mock_runner fails) and once returning fixed code
/// (mock_runner passes).
///
/// Spawns an in-process Anthropic mock that returns a broken Lua fenced block on
/// the first POST /v1/messages request and a fixed Lua fenced block on the second.
/// The Lua fixture's `mock_runner` closure enforces strict fail-then-pass
/// sequencing via a `call_count` upvalue (Crux #2).
///
/// Validates Crux #1: the fixture supplies `base_url` from `ANTHROPIC_BASE_URL_TEST`;
/// if `blocks/compile_loop/init.lua` did not forward `opts.base_url` to the Anthropic
/// client (ST1 fix), the request would not reach the mock and the test would fail.
///
/// No `#[ignore]` — runs under plain `cargo test` with no API keys (Crux #3).
/// `ANTHROPIC_API_KEY` is not set; `api_key="dummy"` is injected as a literal.
#[tokio::test]
async fn compile_loop_anthropic_mock_iterates_until_pass() {
    let (base_url, call_count, ct) =
        common::compile_loop_anthropic_mock::spawn_compile_loop_anthropic_mock_server().await;
    // Give the server a moment to start accepting connections before the subprocess runs.
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let url_clone = base_url.clone();
    tokio::task::spawn_blocking(move || {
        // Safety: tempdir() panics only on OS-level temp directory failure,
        // which is a fatal test infra condition, not a recoverable error.
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args(["-s", &common::fixture("compile_loop_anthropic_mock.lua")])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_MOCK_PASS"));
    })
    .await
    // Safety: spawn_blocking does not panic on its own; any panic would come from
    // the assertion block above failing, which we want to propagate.
    .expect("subprocess assertion task should not panic");

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        2,
        "expected exactly 2 HTTP calls to the anthropic mock"
    );
    ct.cancel();
}

/// Verifies compile_loop in multi-file diff mode (happy path, 1-turn, 2-file).
///
/// Scenario: 1 iteration.
///   - Mock returns path-header SEARCH/REPLACE for both file_a and file_b in a single turn.
///   - apply_blocks succeeds for both files → mock_runner receives paths list → ok=true.
///
/// Validates:
///   - target_files list is accepted (Crux #2 backward-compatible conf API).
///   - Parser extracts path headers and routes each block to the correct file (Crux #1).
///   - Runner is called with a list of paths, not a single string (Crux #3 signature toggle).
///   - result.modified_files contains 2 paths; result.artifact_path is nil.
///   - Loop converges on the first LLM call (call_count == 1).
///
/// No `#[ignore]` — runs under plain `cargo test` with no API keys.
#[tokio::test]
async fn compile_loop_diff_multi_anthropic_mock_iterates_until_pass() {
    let handle = MockLlm::anthropic(|req| {
        let (path_a, path_b) = two_paths(&req.paths);
        anthropic::text_response(&sr_text_both(&path_a, &path_b))
    })
    .spawn()
    .await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let url_clone = handle.base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let file_a = tmp.path().join("file_a.lua");
        let file_b = tmp.path().join("file_b.lua");
        common::agent_block_cmd()
            .args([
                "-s",
                &common::fixture("compile_loop_diff_multi_anthropic_mock.lua"),
            ])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET_FILES",
                format!(
                    "{}:{}",
                    file_a.to_str().expect("utf8 path"),
                    file_b.to_str().expect("utf8 path")
                ),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains(
                "COMPILE_LOOP_DIFF_MULTI_MOCK_PASS",
            ));
    })
    .await
    .expect("subprocess assertion task should not panic");

    // Happy path: exactly 1 HTTP call (both files patched in a single LLM turn).
    assert_eq!(
        handle.state.call_count(),
        1,
        "expected exactly 1 HTTP call to the multi diff mock (happy path: 2 files in 1 turn)"
    );
    handle.ct.cancel();
}

/// Verifies the apply_search_replace write-channel tool (issue #1 request 1).
///
/// Scenario: 1 iteration, 2 LLM calls.
///   - Call 1: mock returns two apply_search_replace tool_use blocks (file_a, file_b).
///     compile_loop applies both edits via the tool handler and writes them to disk.
///   - Call 2: mock returns the plain text "DONE" (no SR blocks). Because tool-channel
///     edits were applied this iter, the loop proceeds to verify instead of treating
///     the missing SR text as a parse failure → mock_runner sees "new" → ok=true.
///
/// Validates:
///   - tool_mode default "auto" declares apply_search_replace (asserted via mock state).
///   - Tool-channel edits count as applied edits (no zero-edit retry / no dead end).
///   - result.modified_files carries the tool-written paths.
///
/// No `#[ignore]` — runs under plain `cargo test` with no API keys.
#[tokio::test]
async fn compile_loop_apply_search_replace_tool_converges() {
    let handle = MockLlm::anthropic(|req| {
        if !req.has_tool_results {
            let (path_a, path_b) = two_paths(&req.paths);
            anthropic::tool_use_response(vec![
                anthropic::tool_use(
                    "toolu_asr_1",
                    "apply_search_replace",
                    json!({"path": path_a, "search": "print(\"a-old\")", "replace": "print(\"a-new\")"}),
                ),
                anthropic::tool_use(
                    "toolu_asr_2",
                    "apply_search_replace",
                    json!({"path": path_b, "search": "print(\"b-old\")", "replace": "print(\"b-new\")"}),
                ),
            ])
        } else {
            anthropic::text_response("DONE")
        }
    })
    .spawn()
    .await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let url_clone = handle.base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let file_a = tmp.path().join("file_a.lua");
        let file_b = tmp.path().join("file_b.lua");
        common::agent_block_cmd()
            .args([
                "-s",
                &common::fixture("compile_loop_asr_anthropic_mock.lua"),
            ])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET_FILES",
                format!(
                    "{}:{}",
                    file_a.to_str().expect("utf8 path"),
                    file_b.to_str().expect("utf8 path")
                ),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_ASR_MOCK_PASS"));
    })
    .await
    .expect("subprocess assertion task should not panic");

    assert_eq!(
        handle.state.call_count(),
        2,
        "expected exactly 2 HTTP calls (tool_use turn + DONE turn)"
    );
    assert!(
        handle.state.declared_count_of("apply_search_replace") >= 1,
        "tool_mode=auto must declare the apply_search_replace tool in the request"
    );
    handle.ct.cancel();
}

/// Verifies wire-shape tolerance for the "broken OpenAI" tool_calls form.
///
/// Observed on OpenAI-compatible stacks in the wild (Ollama native leak-through,
/// Gemini functionCall.args, some vLLM tool-call parsers):
///   * function.arguments arrives as a JSON *object* instead of a string.
///   * the id field is absent.
///
/// Scenario: 1 iteration, 2 LLM calls.
///   - Call 1: two apply_search_replace tool_calls (object args, no ids).
///     cl_oai_normalize must accept the object arguments and synthesize
///     deterministic call_synth_N ids.
///   - Call 2: request must carry role="tool" messages whose tool_call_id
///     starts with "call_synth_" (asserted via mock state); mock replies "DONE"
///     → loop proceeds to verify via tool-channel edits → ok=true.
///
/// No `#[ignore]` — runs under plain `cargo test` with no API keys.
#[tokio::test]
async fn compile_loop_broken_openai_tool_calls_shape_converges() {
    let handle = MockLlm::openai(|req| {
        if !req.has_tool_results {
            let (path_a, path_b) = two_paths(&req.paths);
            openai::tool_calls_response(vec![
                openai::tool_call_object_args_no_id(
                    "apply_search_replace",
                    json!({"path": path_a, "search": "print(\"a-old\")", "replace": "print(\"a-new\")"}),
                ),
                openai::tool_call_object_args_no_id(
                    "apply_search_replace",
                    json!({"path": path_b, "search": "print(\"b-old\")", "replace": "print(\"b-new\")"}),
                ),
            ])
        } else {
            openai::text_response("DONE")
        }
    })
    .spawn()
    .await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let url_clone = handle.base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let file_a = tmp.path().join("file_a.lua");
        let file_b = tmp.path().join("file_b.lua");
        common::agent_block_cmd()
            .args([
                "-s",
                &common::fixture("compile_loop_broken_openai_mock.lua"),
            ])
            .env("OPENAI_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET_FILES",
                format!(
                    "{}:{}",
                    file_a.to_str().expect("utf8 path"),
                    file_b.to_str().expect("utf8 path")
                ),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains(
                "COMPILE_LOOP_BROKEN_OPENAI_MOCK_PASS",
            ));
    })
    .await
    .expect("subprocess assertion task should not panic");

    assert_eq!(
        handle.state.call_count(),
        2,
        "expected exactly 2 HTTP calls (broken tool_calls turn + DONE turn)"
    );
    let ids = handle.state.tool_result_ids();
    assert!(
        ids.len() >= 2,
        "expected >=2 role=tool messages carrying tool results, got {ids:?}"
    );
    assert!(
        ids.iter().all(|id| id.starts_with("call_synth_")),
        "every role=tool message must carry a synthesized call_synth_* id, got {ids:?}"
    );
    handle.ct.cancel();
}

/// Verifies tool_mode="none" declares no tools (issue #1 request 2).
///
/// Scenario: 1 iteration, 1 LLM call.
///   - The caller inlines all file contents in the spec and sets tool_mode="none".
///   - The request must NOT carry a "tools" key (mock records; asserted below).
///   - Mock returns path-header SEARCH/REPLACE text → apply → ok=true.
///
/// No `#[ignore]` — runs under plain `cargo test` with no API keys.
#[tokio::test]
async fn compile_loop_tool_mode_none_declares_no_tools() {
    let handle = MockLlm::anthropic(|req| {
        let (path_a, path_b) = two_paths(&req.paths);
        anthropic::text_response(&sr_text_both(&path_a, &path_b))
    })
    .spawn()
    .await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let url_clone = handle.base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let file_a = tmp.path().join("file_a.lua");
        let file_b = tmp.path().join("file_b.lua");
        common::agent_block_cmd()
            .args([
                "-s",
                &common::fixture("compile_loop_tool_mode_none_mock.lua"),
            ])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET_FILES",
                format!(
                    "{}:{}",
                    file_a.to_str().expect("utf8 path"),
                    file_b.to_str().expect("utf8 path")
                ),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains(
                "COMPILE_LOOP_TOOL_MODE_NONE_MOCK_PASS",
            ));
    })
    .await
    .expect("subprocess assertion task should not panic");

    assert_eq!(
        handle.state.call_count(),
        1,
        "expected exactly 1 HTTP call (single-turn SR text)"
    );
    assert_eq!(
        handle.state.tools_declared_count(),
        0,
        "tool_mode=none must not declare any tools in the request"
    );
    handle.ct.cancel();
}

/// Verifies compile_loop in multi-file diff mode converges after a SEARCH mismatch (2-iter).
///
/// Scenario: 2 iterations.
///   - Iter 1: mock returns file_a SEARCH with wrong text ("WRONG") — apply fails for file_a.
///     compile_loop feeds back a failure message, triggering a second LLM call.
///   - Iter 2: mock returns correct SEARCH for both file_a and file_b → apply succeeds → ok=true.
///
/// Validates:
///   - A SEARCH mismatch in multi-file mode triggers a retry (not a silent skip).
///   - Loop converges on the second LLM call (call_count == 2).
///   - result.modified_files contains 2 paths; result.artifact_path is nil.
///
/// No `#[ignore]` — runs under plain `cargo test` with no API keys.
#[tokio::test]
async fn compile_loop_diff_multi_anthropic_mock_two_iter_converges() {
    let handle = MockLlm::anthropic(|req| {
        let (path_a, path_b) = two_paths(&req.paths);
        if req.call_index == 0 {
            // Turn 1: file_a only, with deliberately wrong SEARCH text.
            anthropic::text_response(&format!(
                "<<< path={path_a} >>>\n<<<<<<< SEARCH\nprint(\"WRONG\")\n=======\nprint(\"a-new\")\n>>>>>>> REPLACE"
            ))
        } else {
            anthropic::text_response(&sr_text_both(&path_a, &path_b))
        }
    })
    .spawn()
    .await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let url_clone = handle.base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let file_a = tmp.path().join("file_a.lua");
        let file_b = tmp.path().join("file_b.lua");
        common::agent_block_cmd()
            .args([
                "-s",
                &common::fixture("compile_loop_diff_multi_anthropic_mock_two_iter.lua"),
            ])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET_FILES",
                format!(
                    "{}:{}",
                    file_a.to_str().expect("utf8 path"),
                    file_b.to_str().expect("utf8 path")
                ),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains(
                "COMPILE_LOOP_DIFF_MULTI_MOCK_TWO_ITER_PASS",
            ));
    })
    .await
    .expect("subprocess assertion task should not panic");

    // 2-iter: exactly 2 HTTP calls (iter1: apply-fail, iter2: pass).
    assert_eq!(
        handle.state.call_count(),
        2,
        "expected exactly 2 HTTP calls to the multi diff mock (iter1: apply-fail, iter2: pass)"
    );
    handle.ct.cancel();
}

/// Verifies the compile_loop distill subloop with an OpenAI provider mock.
///
/// Scenario (3-turn per iter, with distill LLM calls interleaved):
///   Turn 0 (main, with tools):   mock returns tool_use=read_file for the target file.
///                                 compile_loop dispatches read_file → size > threshold →
///                                 calls distill_subloop → N HTTP calls to mock (no tools).
///   Turn 1 (distill, no tools):  mock returns short text summaries.
///                                 distill_call_count incremented per chunk.
///   Turn 2 (main, with tools + tool results): mock returns SR pass block.
///                                 compile_loop applies SR → mock_runner returns ok=true.
///
/// Asserts:
///   - COMPILE_LOOP_DISTILL_MOCK_PASS received (loop converged).
///   - distill_call_count > 0 (distill subloop was triggered).
///   - received_distill_body has no `tools` key (BC5: provider-agnostic distill).
///
/// No `#[ignore]` — runs under plain `cargo test` with no real API keys.
#[tokio::test]
async fn compile_loop_distill_openai_mock_iterates_until_pass() {
    let (addr, state) = common::compile_loop_distill_mock::spawn_distill_mock("openai").await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let base_url = format!("http://{addr}");
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("distill_target.lua");
        common::agent_block_cmd()
            .args(["-s", &common::fixture("compile_loop_distill_mock.lua")])
            .env("OPENAI_BASE_URL_TEST", &base_url)
            .env("DISTILL_MOCK_PROVIDER", "openai")
            .env(
                "COMPILE_LOOP_DISTILL_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_DISTILL_MOCK_PASS"));
    })
    .await
    .expect("subprocess assertion task should not panic");

    assert!(
        state.distill_call_count.load(Ordering::SeqCst) > 0,
        "distill_call_count must be > 0: distill subloop was not triggered"
    );

    let body_guard = state.received_distill_body.lock().unwrap();
    let distill_body = body_guard
        .as_ref()
        .expect("received_distill_body must be set after distill call");
    assert!(
        distill_body.get("tools").is_none(),
        "BC5: distill LLM call must not include `tools` field in request body"
    );
}

/// Verifies the compile_loop distill subloop with an Anthropic provider mock.
///
/// Same scenario as `compile_loop_distill_openai_mock_iterates_until_pass` but
/// using the Anthropic Messages API schema. Confirms provider-agnostic distill
/// (crux-card §2: distill uses the same call path regardless of provider).
///
/// Asserts:
///   - COMPILE_LOOP_DISTILL_MOCK_PASS received.
///   - distill_call_count > 0.
///   - received_distill_body has no `tools` key (BC5).
///
/// No `#[ignore]` — runs under plain `cargo test` with no real API keys.
#[tokio::test]
async fn compile_loop_distill_anthropic_mock_iterates_until_pass() {
    let (addr, state) = common::compile_loop_distill_mock::spawn_distill_mock("anthropic").await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let base_url = format!("http://{addr}");
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("distill_target.lua");
        common::agent_block_cmd()
            .args(["-s", &common::fixture("compile_loop_distill_mock.lua")])
            .env("ANTHROPIC_BASE_URL_TEST", &base_url)
            .env("DISTILL_MOCK_PROVIDER", "anthropic")
            .env(
                "COMPILE_LOOP_DISTILL_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_DISTILL_MOCK_PASS"));
    })
    .await
    .expect("subprocess assertion task should not panic");

    assert!(
        state.distill_call_count.load(Ordering::SeqCst) > 0,
        "distill_call_count must be > 0: distill subloop was not triggered"
    );

    let body_guard = state.received_distill_body.lock().unwrap();
    let distill_body = body_guard
        .as_ref()
        .expect("received_distill_body must be set after distill call");
    assert!(
        distill_body.get("tools").is_none(),
        "BC5: distill LLM call must not include `tools` field in request body"
    );
}

/// Verifies that read_file_range returns verbatim source lines without distillation
/// even when the target file exceeds READ_FILE_FULL_THRESHOLD (crux-card §3).
///
/// Scenario (Anthropic mock, 2 turns):
///   Turn 0: mock returns tool_use=read_file_range(path, 10, 20).
///           compile_loop dispatches to read_file_range_tool_handler.
///           Handler reads lines 10-20 verbatim (no distill path).
///   Turn 1: mock returns SR block (REPLACE_ME → DONE) after tool result.
///           compile_loop applies SR → mock_runner returns ok=true.
///
/// Asserts:
///   - READ_FILE_RANGE_VERBATIM_PASS received (loop converged using range access).
///   - call_count == 2 (exactly 2 main LLM calls, no distill interleaved).
///
/// No `#[ignore]` — runs under plain `cargo test` with no real API keys.
#[tokio::test]
async fn compile_loop_read_file_range_verbatim() {
    let (addr, state) = common::compile_loop_distill_mock::spawn_range_mock().await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let base_url = format!("http://{addr}");
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("range_target.lua");
        common::agent_block_cmd()
            .args([
                "-s",
                &common::fixture("compile_loop_distill_range_mock.lua"),
            ])
            .env("ANTHROPIC_BASE_URL_TEST", &base_url)
            .env(
                "COMPILE_LOOP_RANGE_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains("READ_FILE_RANGE_VERBATIM_PASS"));
    })
    .await
    .expect("subprocess assertion task should not panic");

    // Range mock: exactly 2 main calls (turn 0 + turn 1), no distill calls.
    assert_eq!(
        state.call_count.load(Ordering::SeqCst),
        2,
        "expected exactly 2 HTTP calls to the range mock (turn 0: read_file_range, turn 1: SR pass)"
    );
    assert_eq!(
        state.distill_call_count.load(Ordering::SeqCst),
        0,
        "range mock must not trigger distill subloop (read_file_range bypasses distill)"
    );
}

/// Verifies that compile_loop with the OpenAI provider converges after exactly 3 turns
/// (broken1 → broken2 → fixed) and that the same input sequence produces the same
/// output sequence across two independent subprocess runs (Crux: deterministic across runs).
///
/// ## Scenario
/// - Turn 1: mock returns broken Lua code A; mock_runner returns {ok=false, stderr="iter 1"}.
/// - Turn 2: mock returns broken Lua code B (different from A to avoid early stagnation);
///           mock_runner returns {ok=false, stderr="iter 2"}.
/// - Turn 3: mock returns fixed Lua code; mock_runner returns {ok=true}.
///
/// ## Determinism check (Crux constraint — 1 spawn縮退不可)
/// The test spawns two subprocesses against the same mock server:
///   Run 1: assert call_count == 3 and stdout contains "COMPILE_LOOP_MOCK_PASS".
///   call_count.store(0, SeqCst) — reset between runs.
///   Run 2: assert call_count == 3 and stdout contains "COMPILE_LOOP_MOCK_PASS".
/// Both runs passing with identical call counts demonstrates that identical input
/// sequences produce identical tool-call sequences across runs.
///
/// No `#[ignore]` — runs under plain `cargo test` with no API keys.
/// api_key is always "dummy" (OPENAI_API_KEY is never read).
#[tokio::test]
async fn compile_loop_openai_mock_three_turn_converges() {
    let (base_url, call_count, ct) = common::compile_loop_openai_mock_three_turn::spawn_compile_loop_openai_mock_three_turn_server().await;
    // Give the server a moment to start accepting connections before the subprocess runs.
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    // --- Run 1 ---
    let url_clone = base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args([
                "-s",
                &common::fixture("compile_loop_openai_mock_three_turn.lua"),
            ])
            .env("OPENAI_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_MOCK_PASS"));
    })
    .await
    .expect("subprocess assertion task (run 1) should not panic");

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        3,
        "run 1: expected exactly 3 HTTP calls to the 3-turn mock (broken1, broken2, fixed)"
    );

    // Reset between runs — AtomicUsize store is safe here: run 1 subprocess has exited.
    call_count.store(0, Ordering::SeqCst);

    // --- Run 2 (deterministic check: same input → same output sequence) ---
    let url_clone2 = base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args([
                "-s",
                &common::fixture("compile_loop_openai_mock_three_turn.lua"),
            ])
            .env("OPENAI_BASE_URL_TEST", &url_clone2)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("RUST_LOG", "off")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_MOCK_PASS"));
    })
    .await
    .expect("subprocess assertion task (run 2) should not panic");

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        3,
        "run 2: expected exactly 3 HTTP calls to the 3-turn mock (broken1, broken2, fixed)"
    );

    ct.cancel();
}

/// Verifies that compile_loop emits ab.obs events when AGENT_BLOCK_LLM_DUMP=meta.
///
/// Reuses the Anthropic mock (fail-then-pass shape, 2 HTTP calls).
/// With AGENT_BLOCK_LLM_DUMP=meta the obs helpers are activated and the three
/// events that appear on the PASS path — iter_start, iter_result, converged —
/// must appear in stdout.
///
/// stagnation and max_iters_reached are not asserted: they do not occur in the
/// 2-iteration PASS shape produced by this mock.
#[tokio::test]
async fn compile_loop_anthropic_mock_emits_obs_events() {
    let (base_url, call_count, ct) =
        common::compile_loop_anthropic_mock::spawn_compile_loop_anthropic_mock_server().await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    let url_clone = base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args(["-s", &common::fixture("compile_loop_anthropic_mock.lua")])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "info")
            .env("AGENT_BLOCK_LLM_DUMP", "meta")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_MOCK_PASS"))
            .stdout(predicate::str::contains(
                "prefix=ab.obs event=iter_start component=compile_loop",
            ))
            .stdout(predicate::str::contains(
                "prefix=ab.obs event=iter_result component=compile_loop",
            ))
            .stdout(predicate::str::contains(
                "prefix=ab.obs event=converged component=compile_loop",
            ));
    })
    .await
    .expect("subprocess assertion task should not panic");

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        2,
        "expected exactly 2 HTTP calls to the anthropic mock"
    );
    ct.cancel();
}

/// Verifies that AGENT_BLOCK_LLM_DUMP=full emits prompt/response bodies from the
/// compile_loop llm_call path, and that meta mode does not.
///
/// Reuses the Anthropic mock (fail-then-pass shape, 2 HTTP calls) and runs the
/// subprocess twice against it:
///   Run 1 (full): stdout must carry `event=request_body component=compile_loop`
///                 (the request body holds the full messages array — the audit trail).
///   Run 2 (meta): the same events must NOT appear; meta output stays meta-only.
///
/// No `#[ignore]` — self-contained, runs under plain `cargo test` with no API keys.
#[tokio::test]
async fn compile_loop_anthropic_mock_full_dump_emits_bodies() {
    let (base_url, call_count, ct) =
        common::compile_loop_anthropic_mock::spawn_compile_loop_anthropic_mock_server().await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    // --- Run 1: full mode → request/response bodies present ---
    let url_clone = base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args(["-s", &common::fixture("compile_loop_anthropic_mock.lua")])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "info")
            .env("AGENT_BLOCK_LLM_DUMP", "full")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_MOCK_PASS"))
            .stdout(predicate::str::contains(
                "prefix=ab.obs event=request_body component=compile_loop",
            ))
            .stdout(predicate::str::contains(
                "prefix=ab.obs event=response_body component=compile_loop",
            ))
            .stdout(predicate::str::contains(
                "prefix=ab.obs event=request_headers component=compile_loop",
            ))
            .stdout(predicate::str::contains("***REDACTED***"))
            // The fixture injects api_key="dummy"; it must never reach the dump.
            // Global (whole-stdout) form is safe here: the key value is not logged
            // anywhere else and the mock never echoes it back.
            .stdout(predicate::str::contains("dummy").not());
    })
    .await
    .expect("subprocess assertion task (full) should not panic");

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        2,
        "full run: expected exactly 2 HTTP calls to the anthropic mock"
    );

    // Reset between runs — the mock keys its fail-then-pass shape off call_count,
    // and the run 1 subprocess has already exited.
    call_count.store(0, Ordering::SeqCst);

    // --- Run 2: meta mode → bodies must stay absent ---
    let url_clone2 = base_url.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args(["-s", &common::fixture("compile_loop_anthropic_mock.lua")])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone2)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "info")
            .env("AGENT_BLOCK_LLM_DUMP", "meta")
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_MOCK_PASS"))
            .stdout(predicate::str::contains("event=request_body").not())
            .stdout(predicate::str::contains("event=response_body").not());
    })
    .await
    .expect("subprocess assertion task (meta) should not panic");

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        2,
        "meta run: expected exactly 2 HTTP calls to the anthropic mock"
    );
    ct.cancel();
}

/// Verifies the primitive-level JSONL dump sink (`AGENT_BLOCK_LLM_DUMP_DIR`).
///
/// Reuses the Anthropic mock (fail-then-pass shape, 2 HTTP calls) and runs the
/// subprocess twice:
///   Run 1 (`AGENT_BLOCK_LLM_DUMP=full` + sink dir): exactly one `*.jsonl` file
///          is written, carrying `http_request` / `http_response` records; the
///          `x-api-key` header is redacted and the raw key never appears.
///   Run 2 (`AGENT_BLOCK_LLM_DUMP=meta` + a fresh sink dir): nothing is written,
///          because the block only flags requests under full mode.
///
/// No `#[ignore]` — self-contained, runs under plain `cargo test` with no API keys.
#[tokio::test]
async fn compile_loop_full_dump_writes_jsonl_sink() {
    let (base_url, call_count, ct) =
        common::compile_loop_anthropic_mock::spawn_compile_loop_anthropic_mock_server().await;
    tokio::time::sleep(std::time::Duration::from_millis(50)).await;

    // --- Run 1: full mode + sink dir → one JSONL file ---
    let dump_dir = tempdir().expect("dump tempdir");
    let dump_path = dump_dir.path().to_path_buf();

    let url_clone = base_url.clone();
    let dump_path_run = dump_path.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args(["-s", &common::fixture("compile_loop_anthropic_mock.lua")])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "info")
            .env("AGENT_BLOCK_LLM_DUMP", "full")
            .env("AGENT_BLOCK_LLM_DUMP_DIR", &dump_path_run)
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_MOCK_PASS"));
    })
    .await
    .expect("subprocess assertion task (sink) should not panic");

    let sink_files: Vec<std::path::PathBuf> = std::fs::read_dir(&dump_path)
        .expect("read dump dir")
        .filter_map(|e| e.ok().map(|e| e.path()))
        .filter(|p| p.extension().and_then(|s| s.to_str()) == Some("jsonl"))
        .collect();
    assert_eq!(
        sink_files.len(),
        1,
        "expected exactly one jsonl sink file per process, got {sink_files:?}"
    );

    let content = std::fs::read_to_string(&sink_files[0]).expect("read sink file");
    let records: Vec<serde_json::Value> = content
        .lines()
        .filter(|l| !l.trim().is_empty())
        .map(|l| serde_json::from_str(l).expect("each sink line must be valid JSON"))
        .collect();

    let requests: Vec<&serde_json::Value> = records
        .iter()
        .filter(|r| r["kind"] == "http_request")
        .collect();
    let responses: Vec<&serde_json::Value> = records
        .iter()
        .filter(|r| r["kind"] == "http_response")
        .collect();
    assert!(
        !requests.is_empty(),
        "sink must carry at least one http_request record: {content}"
    );
    assert!(
        !responses.is_empty(),
        "sink must carry at least one http_response record: {content}"
    );

    // The fixture injects api_key="dummy" as the x-api-key header value.
    // `headers` is an array of [name, value] pairs, so repeated names survive.
    let api_key_values: Vec<&str> = requests[0]["headers"]
        .as_array()
        .expect("headers must be an array of [name, value] pairs")
        .iter()
        .filter(|pair| pair[0] == "x-api-key")
        .filter_map(|pair| pair[1].as_str())
        .collect();
    assert_eq!(
        api_key_values,
        ["***REDACTED***"],
        "x-api-key must be present and redacted in the sink: {}",
        requests[0]
    );
    assert!(
        !content.contains("dummy"),
        "the raw api key value must not appear anywhere in the sink file"
    );

    // The mock always answers with model "claude-haiku-mock" — a stable marker
    // proving the response body text reached the sink verbatim.
    assert!(
        responses.iter().any(|r| r["body"]
            .as_str()
            .is_some_and(|b| b.contains("claude-haiku-mock"))),
        "a response record must carry the mock response body: {content}"
    );

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        2,
        "sink run: expected exactly 2 HTTP calls to the anthropic mock"
    );

    // Reset between runs — the mock keys its fail-then-pass shape off call_count.
    call_count.store(0, Ordering::SeqCst);

    // --- Run 2: meta mode + fresh sink dir → nothing written ---
    let meta_dir = tempdir().expect("meta dump tempdir");
    let meta_path = meta_dir.path().to_path_buf();

    let url_clone2 = base_url.clone();
    let meta_path_run = meta_path.clone();
    tokio::task::spawn_blocking(move || {
        let tmp = tempdir().expect("tempdir");
        let target_file = tmp.path().join("target.lua");
        common::agent_block_cmd()
            .args(["-s", &common::fixture("compile_loop_anthropic_mock.lua")])
            .env("ANTHROPIC_BASE_URL_TEST", &url_clone2)
            .env(
                "COMPILE_LOOP_TARGET",
                target_file.to_str().expect("utf8 path"),
            )
            .env("AGENT_BLOCK_HOME", tmp.path())
            .env("RUST_LOG", "info")
            .env("AGENT_BLOCK_LLM_DUMP", "meta")
            .env("AGENT_BLOCK_LLM_DUMP_DIR", &meta_path_run)
            .assert()
            .success()
            .stdout(predicate::str::contains("COMPILE_LOOP_MOCK_PASS"));
    })
    .await
    .expect("subprocess assertion task (meta sink) should not panic");

    let meta_entries = std::fs::read_dir(&meta_path)
        .expect("read meta dump dir")
        .count();
    // No request carries dump="full" under meta mode, so the sink is never opened.
    assert_eq!(meta_entries, 0, "meta mode must not write to the sink dir");

    assert_eq!(
        call_count.load(Ordering::SeqCst),
        2,
        "meta sink run: expected exactly 2 HTTP calls to the anthropic mock"
    );
    ct.cancel();
}