//! The 0.1 tools end to end (spec §15.2, §14.1, §12.3, §9.2): two agents

//! talk through the real daemon, `wait` wakes at once and refuses an idle

//! loop, the rules line appears until the rules are read, every call is

//! recorded with its arguments in full, and the ledger verifies.

mod common;

use common::{add_agent, run, setup, Serving};

use serde_json::{json, Value};

use spectra_core::keys::KeyPair;

use spectra_mcp::client::{rpc_result, Client};

use std::time::{Duration, Instant};

async fn call(c: &Client, name: &str, args: Value) -> Value {

    let req = json!({ "jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": { "name": name, "arguments": args,

        "_meta": { "io.modelcontextprotocol/protocolVersion": "2026-07-28" } } });

    let r = c.mcp("2026-07-28", &req).await.unwrap();

    assert_eq!(r.status, 200, "{}", String::from_utf8_lossy(&r.body));

    rpc_result(&r).unwrap()["result"].clone()

}

fn text(v: &Value) -> String {

    v["content"][0]["text"].as_str().unwrap_or("").to_string()

}

#[tokio::test]

async fn two_agents_talk_and_every_call_is_on_the_record() {

    let dir = setup();

    let d = dir.path();

    std::fs::create_dir_all(d.join("data/rules")).unwrap();

    std::fs::write(d.join("data/rules/site.md"), "Commit with oxy, never git.\n").unwrap();

    let claude: KeyPair = add_agent(d, "claude-oxygen", &[]);

    let kimi: KeyPair = add_agent(d, "kimi-oxygen", &[]);

    let srv = Serving::start(d);

    let (c, k) = (Client::new(&srv.socket, Some(claude)), Client::new(&srv.socket, Some(kimi)));

    let b = call(&c, "brief", json!({})).await;

    let t = text(&b);

    assert!(t.contains("You are claude-oxygen · Andy McCall's agent") && t.contains("Commit with oxy, never git."), "{t}");

    assert!(t.contains("kimi-oxygen · Andy McCall's agent"), "{t}");

    let version = b["structuredContent"]["rules"]["version"].as_str().unwrap().to_string();

    call(&k, "brief", json!({})).await;

    // kimi waits; claude mentions it; kimi wakes at once.

    let waiter = tokio::spawn({

        let k = Client::new(&srv.socket, Some(KeyPair::load_home(&d.join("agents/kimi-oxygen")).unwrap()));

        async move {

            let started = Instant::now();

            let r = call(&k, "wait", json!({ "timeout_s": 20 })).await;

            (r, started.elapsed())

        }

    });

    tokio::time::sleep(Duration::from_millis(300)).await;

    let s = call(&c, "say", json!({ "body": "@kimi-oxygen the wire protocol grew a field", "channel": "general" })).await;

    let id = s["structuredContent"]["id"].as_str().unwrap().to_string();

    let (woke, waited) = waiter.await.unwrap();

    assert!(

        text(&woke).contains("the wire protocol grew a field") && text(&woke).contains("[mention from claude-oxygen (Andy McCall's agent"),

        "{}",

        text(&woke)

    );

    assert!(waited < Duration::from_secs(5), "woke after {waited:?}, not at its 20 s timeout");

    let r = call(&k, "read", json!({ "thread": id })).await;

    assert!(text(&r).contains("[from claude-oxygen (Andy McCall's agent, claude-code)") && text(&r).contains("[end]"), "{}", text(&r));

    call(&k, "say", json!({ "body": "thanks, bumping the pin", "reply_to": id })).await;

    call(&k, "ack", json!({ "ids": [id], "reaction": "ack" })).await;

    assert!(text(&call(&k, "inbox", json!({})).await).contains("Nothing unread"));

    let hits = call(&c, "search", json!({ "query": "pin", "since": "1d" })).await;

    assert_eq!(hits["structuredContent"]["hits"].as_array().unwrap().len(), 1, "{hits}");

    call(&c, "status", json!({ "state": "working", "text": "reviewing the field" })).await;

    let a = call(&k, "agents", json!({})).await;

    assert!(text(&a).contains("busy — \"reviewing the field\""), "{}", text(&a));

    // The rules change: the next result says so until `rules` is called.

    std::fs::write(d.join("data/rules/site.md"), "Commit with oxy, never git. Add a changelog line.\n").unwrap();

    let r = call(&c, "inbox", json!({})).await;

    assert!(text(&r).starts_with(&format!("House rules changed ({version} → ")), "{}", text(&r));

    let rr = call(&c, "rules", json!({})).await;

    assert!(text(&rr).contains("Add a changelog line."));

    assert!(!text(&call(&c, "inbox", json!({})).await).starts_with("House rules changed"));

    // Redaction and a refusal come back as results, never protocol errors.

    let mine = call(&c, "say", json!({ "body": "oops, a secret" })).await["structuredContent"]["id"].as_str().unwrap().to_string();

    assert_eq!(call(&k, "redact", json!({ "id": mine, "reason": "not yours" })).await["isError"], true);

    assert_eq!(call(&c, "redact", json!({ "id": mine, "reason": "pasted by mistake" })).await["isError"], false);

    assert_eq!(call(&c, "say", json!({ "body": "x", "channel": "system" })).await["isError"], true);

    srv.stop();

    let v: Value = serde_json::from_slice(&run(d, &["admin", "verify", "--json"]).stdout).unwrap();

    assert!(v["findings"].as_array().unwrap().is_empty(), "{v}");

    let pool = sqlx::SqlitePool::connect(&format!("sqlite://{}", d.join("data/spectra.db").display())).await.unwrap();

    let calls: Vec<(String, String)> =

        sqlx::query_as("SELECT tool, args FROM tool_calls WHERE agent = 'claude-oxygen' ORDER BY seq").fetch_all(&pool).await.unwrap();

    assert!(calls.iter().any(|(t, _)| t == "say"));

    let (_, args) = calls.iter().find(|(t, _)| t == "say").unwrap();

    let stored = spectra_core::attachments::get(&d.join("data"), args).expect("arguments kept in full");

    assert!(String::from_utf8_lossy(&stored).contains("the wire protocol grew a field"));

}

#[tokio::test]

async fn an_idle_wait_loop_is_refused() {

    let dir = setup();

    let d = dir.path();

    let a = add_agent(d, "idler", &[]);

    let srv = Serving::start(d);

    let c = Client::new(&srv.socket, Some(a));

    for _ in 0..3 {

        let r = call(&c, "wait", json!({ "timeout_s": 1 })).await;

        assert_eq!((r["isError"].as_bool(), text(&r).as_str()), (Some(false), "Nothing new."));

    }

    let started = Instant::now();

    let r = call(&c, "wait", json!({ "timeout_s": 50 })).await;

    assert_eq!(r["isError"], true);

    assert!(text(&r).contains("End your turn"), "{}", text(&r));

    assert!(started.elapsed() < Duration::from_secs(2), "refused at once");

    srv.stop();

    let pool = sqlx::SqlitePool::connect(&format!("sqlite://{}", d.join("data/spectra.db").display())).await.unwrap();

    let waits: i64 =

        sqlx::query_scalar("SELECT COUNT(*) FROM tool_calls WHERE tool = 'wait' AND is_error = 0").fetch_one(&pool).await.unwrap();

    assert_eq!(waits, 0, "empty waits are not recorded");

}

#[tokio::test]

async fn the_tool_list_fits_its_token_budget() {

    let dir = setup();

    let d = dir.path();

    let a = add_agent(d, "counter", &[]);

    let srv = Serving::start(d);

    let c = Client::new(&srv.socket, Some(a));

    let r = c.mcp("2026-07-28", &json!({ "jsonrpc": "2.0", "id": 1, "method": "tools/list", "params": {} })).await.unwrap();

    let tools = serde_json::to_string(&r.json().unwrap()["result"]["tools"]).unwrap();

    // About four bytes a token: 1,500 tokens (spec §15.2).

    assert!(tools.len() <= 6_000, "tools/list is {} bytes, about {} tokens", tools.len(), tools.len() / 4);

    srv.stop();

}