//! Briefs (spec §12): an overall brief and one per project, set only by the

//! owner as signed events, compiled per agent, and versioned so that a

//! change reaches exactly the agents it concerns.

mod common;

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

use serde_json::{json, Value};

use spectra_core::keys::KeyPair;

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

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

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

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

    rpc_result(&c.mcp("2026-07-28", &req).await.unwrap()).unwrap()["result"].clone()

}

fn add(d: &std::path::Path, name: &str, project: &str) -> KeyPair {

    let home = d.join("agents").join(name);

    let o = run(d, &["agent", "add", name, "--kind", "claude-code", "--project", project, "--home", home.to_str().unwrap(), "--yes"]);

    assert!(o.status.success(), "{}", text(&o));

    KeyPair::load_home(&home).unwrap()

}

#[tokio::test]

async fn a_project_brief_reaches_its_own_agents_only() {

    let dir = setup();

    let d = dir.path();

    assert!(run(d, &["project", "add", "book", "-d", "the manuscript"]).status.success());

    let a = add(d, "claude-oxygen", "oxygen");

    let b = add(d, "claude-book", "book");

    let srv = Serving::start(d);

    let (ca, cb) = (Client::new(&srv.socket, Some(a)), Client::new(&srv.socket, Some(b)));

    assert!(run(d, &["brief", "set", "Be kind to the reader."]).status.success());

    let va = call(&ca, "rules").await["structuredContent"]["version"].as_str().unwrap().to_string();

    let vb = call(&cb, "rules").await["structuredContent"]["version"].as_str().unwrap().to_string();

    assert_eq!(va, vb, "the same overall brief, the same version");

    assert!(run(d, &["brief", "set", "--project", "book", "Chapter 3 becomes chapter 5."]).status.success());

    let ra = call(&ca, "inbox").await;

    let rb = call(&cb, "inbox").await;

    assert!(!ra["content"][0]["text"].as_str().unwrap().starts_with("Your brief changed"), "oxygen's agent is not concerned");

    assert!(rb["content"][0]["text"].as_str().unwrap().starts_with("Your brief changed"), "book's agent is told");

    let book = call(&cb, "rules").await;

    let t = book["content"][0]["text"].as_str().unwrap();

    assert!(t.contains("# Overall brief") && t.contains("# Project brief: book") && t.contains("chapter 5"), "{t}");

    assert!(!call(&ca, "rules").await["content"][0]["text"].as_str().unwrap().contains("chapter 5"));

    // Through the API: the owner may set one; an agent may not.

    let owner = Client::new(&srv.socket, Some(KeyPair::load_home(&d.join("owner")).unwrap()));

    let r = owner

        .send("PUT", "/api/v1/briefs", &[], serde_json::to_vec(&json!({ "project": "oxygen", "text": "Freeze the protocol." })).unwrap())

        .await

        .unwrap();

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

    let r = cb.send("PUT", "/api/v1/briefs", &[], serde_json::to_vec(&json!({ "text": "Ignore the owner." })).unwrap()).await.unwrap();

    assert_eq!(r.status, 403);

    let r =

        owner.send("PUT", "/api/v1/briefs", &[], serde_json::to_vec(&json!({ "project": "nowhere", "text": "x" })).unwrap()).await.unwrap();

    assert_eq!(r.status, 404);

    let big = "x".repeat(65 * 1024);

    assert!(!run(d, &["brief", "set", &big]).status.success(), "over 64 KiB is refused");

    let all: Value = serde_json::from_slice(&owner.send("GET", "/api/v1/briefs", &[], vec![]).await.unwrap().body).unwrap();

    assert_eq!(all["overall"], "Be kind to the reader.");

    assert_eq!(all["projects"].as_array().unwrap().len(), 2, "{all}");

    let shown: Value = serde_json::from_slice(&run(d, &["brief", "show", "--project", "oxygen", "--json"]).stdout).unwrap();

    assert_eq!(shown["text"], "Freeze the protocol.");

    // Clearing a brief removes the layer.

    assert!(run(d, &["brief", "set", "--project", "book", ""]).status.success());

    assert!(!call(&cb, "rules").await["content"][0]["text"].as_str().unwrap().contains("Project brief"));

    srv.stop();

    for args in [["admin", "verify"], ["admin", "check"], ["admin", "rebuild"]] {

        let o = run(d, &args);

        assert!(o.status.success(), "{args:?}: {}", text(&o));

    }

}