//! The MCP server against a reference PDS, driven by an MCP client.

#[path = "../../knotless/tests/common/mod.rs"]
mod common;
use common::*;

use rmcp::ServiceExt;
use rmcp::model::CallToolRequestParams;
use serde_json::{Value, json};

struct Client {
    rt: tokio::runtime::Runtime,
    peer: rmcp::service::RunningService<rmcp::RoleClient, ()>,
}

impl Client {
    fn new(s: &Sandbox) -> Client {
        Client::knowing(s, &Default::default())
    }

    /// A client of a server told what `known` says of versions.
    fn knowing(s: &Sandbox, known: &knotless::update::Known) -> Client {
        Client::of(knotless_mcp::Server::new(ctx(s)).knowing(known))
    }

    /// A client of `server`.
    fn of(server: knotless_mcp::Server) -> Client {
        let rt = tokio::runtime::Runtime::new().unwrap();
        let peer = rt.block_on(async {
            let (server_io, client_io) = tokio::io::duplex(1 << 20);
            tokio::spawn(async move {
                let running = server.serve(server_io).await.unwrap();
                let _ = running.waiting().await;
            });
            ().serve(client_io).await.unwrap()
        });
        Client { rt, peer }
    }

    /// The tool's text, and whether it was an error.
    fn call(&self, tool: &str, args: Value) -> (String, bool) {
        let params = CallToolRequestParams::new(tool.to_string())
            .with_arguments(args.as_object().unwrap().clone());
        let res = self.rt.block_on(self.peer.call_tool(params)).unwrap();
        let text = res.content[0].as_text().unwrap().text.clone();
        (text, res.is_error == Some(true))
    }

    /// Each of the tool's texts, when it answers more than one.
    fn texts(&self, tool: &str, args: Value) -> Vec<String> {
        let params = CallToolRequestParams::new(tool.to_string())
            .with_arguments(args.as_object().unwrap().clone());
        let res = self.rt.block_on(self.peer.call_tool(params)).unwrap();
        assert_ne!(res.is_error, Some(true), "{tool}: {:?}", res.content);
        let texts = res
            .content
            .iter()
            .map(|c| c.as_text().unwrap().text.clone());
        texts.collect()
    }

    fn ok(&self, tool: &str, args: Value) -> String {
        let (text, err) = self.call(tool, args);
        assert!(!err, "{tool}: {text}");
        text
    }

    fn json(&self, tool: &str, args: Value) -> Value {
        serde_json::from_str(&self.ok(tool, args)).unwrap()
    }

    /// The resource at `uri`, its one content as JSON (`mimeType`, and
    /// `text` or `blob`), or the error it is answered with.
    fn read(&self, uri: &str) -> Result<Value, rmcp::model::ErrorData> {
        let params = rmcp::model::ReadResourceRequestParams::new(uri);
        match self.rt.block_on(self.peer.read_resource(params)) {
            Ok(read) => {
                assert_eq!(read.contents.len(), 1, "{read:?}");
                Ok(serde_json::to_value(&read.contents[0]).unwrap())
            }
            Err(rmcp::ServiceError::McpError(err)) => Err(err),
            Err(err) => panic!("{uri}: {err}"),
        }
    }
}

/// Logged in as its account, as `knotless login` leaves a machine.
fn logged_in() -> Sandbox {
    let mut s = Sandbox::new();
    s.set("KNOTLESS_PASSWORD", "");
    let password = s.account.password.clone();
    let handle = s.account.handle.clone();
    assert_eq!(
        s.cli(&["login", &handle, "--password-stdin"], password.as_bytes())
            .0,
        0
    );
    s
}

#[test]
fn an_agent_works_on_a_repository() {
    let s = logged_in();
    let c = Client::new(&s);
    let tools = c.rt.block_on(c.peer.list_all_tools()).unwrap();
    let names: Vec<&str> = tools.iter().map(|t| t.name.as_ref()).collect();
    for tool in [
        "repo_read",
        "repo_commit",
        "repo_search",
        "repo_create",
        "repo_share",
    ] {
        assert!(names.contains(&tool), "{names:?}");
    }

    let created = c.json(
        "repo_create",
        json!({"name": "agentic", "description": "made by a tool"}),
    );
    let repo = created["repo"].as_str().unwrap().to_string();
    assert_eq!(repo, format!("{}/agentic", s.account.handle));
    let (text, err) = c.call("repo_create", json!({"name": "agentic"}));
    assert!(err && text.contains("already exists"), "{text}");

    let first = c.json(
        "repo_commit",
        json!({"repo": repo, "branch": "main", "message": "start", "changes": [
            {"path": "README.md", "content": "# agentic\n\nhello world\n"},
            {"path": "src/main.rs", "content": "fn main() {}\n"},
            {"path": "bin/run", "content": "#!/bin/sh\n", "executable": true},
            {"path": "logo.bin", "base64": "AAEC/w=="},
        ]}),
    );
    assert_eq!(first["changed"], true);
    let second = c.json(
        "repo_commit",
        json!({"repo": format!("knotless://{repo}"), "branch": "main", "message": "tidy", "changes": [
            {"path": "bin/run", "delete": true},
            {"path": "README.md", "content": "# agentic\n\nhello there\n"},
        ], "base": first["sha"]}),
    );
    let (text, err) = c.call(
        "repo_commit",
        json!({"repo": repo, "branch": "main", "message": "x", "changes": [{"path": "a", "content": "x", "delete": true}]}),
    );
    assert!(err && text.contains("exactly one"), "{text}");
    let (text, err) = c.call(
        "repo_commit",
        json!({"repo": repo, "branch": "main", "message": "x", "changes": [{"path": "a", "base64": "!!"}]}),
    );
    assert!(err, "{text}");

    let refs = c.json("repo_refs", json!({"repo": repo}));
    assert_eq!(refs["refs"][0]["sha"], second["sha"]);
    assert_eq!(refs["private"], false);
    // Two commits, two packs, both small enough to ride inline.
    let storage = c.json("repo_storage", json!({"repo": repo}));
    assert_eq!(storage["packs"], 2);
    assert!(storage["bytes"].as_u64().unwrap() > 0, "{storage}");
    assert_eq!(storage["blobBytes"], 0);
    let tree = c.json("repo_tree", json!({"repo": repo}));
    let names: Vec<&str> = tree
        .as_array()
        .unwrap()
        .iter()
        .map(|e| e["name"].as_str().unwrap())
        .collect();
    assert_eq!(names, ["README.md", "logo.bin", "src"]);
    let sub = c.json(
        "repo_tree",
        json!({"repo": repo, "path": "src", "rev": first["sha"]}),
    );
    assert_eq!(sub[0]["name"], "main.rs");
    assert_eq!(
        c.ok("repo_read", json!({"repo": repo, "path": "README.md"})),
        "# agentic\n\nhello there\n"
    );
    assert_eq!(
        c.json("repo_read", json!({"repo": repo, "path": "logo.bin"}))["base64"],
        "AAEC/w=="
    );
    let hits = c.json("repo_search", json!({"repo": repo, "pattern": "HELLO"}));
    assert_eq!(hits[0]["path"], "README.md");
    assert_eq!(hits[0]["line"], 3);
    // Who last changed each run of lines: the line tidied since, after two
    // from the start.
    let blamed = c.json("repo_blame", json!({"repo": repo, "path": "README.md"}));
    assert_eq!(
        (&blamed[0]["sha"], &blamed[0]["count"]),
        (&first["sha"], &json!(2))
    );
    assert_eq!(
        (&blamed[1]["start"], &blamed[1]["summary"]),
        (&json!(3), &json!("tidy"))
    );
    assert_eq!(blamed[1]["previous"]["sha"], first["sha"]);
    let log = c.json("repo_log", json!({"repo": repo, "limit": 5}));
    assert_eq!(log.as_array().unwrap().len(), 2);
    assert_eq!(log[0]["message"], "tidy");
    let touched = c.json("repo_log", json!({"repo": repo, "path": "src"}));
    assert_eq!(touched.as_array().unwrap().len(), 1);
    let diff = c.ok(
        "repo_diff",
        json!({"repo": repo, "base": first["sha"], "head": "main"}),
    );
    assert!(
        diff.contains("-hello world") && diff.contains("+hello there"),
        "{diff}"
    );
    // Nothing changed says so, rather than nothing at all.
    let same = c.ok(
        "repo_diff",
        json!({"repo": repo, "base": "main", "head": "main"}),
    );
    assert_eq!(same, "No differences: main changes nothing since main.");

    // A new branch starts from the default branch, or from `base`, and
    // its commits are the committer's.
    let feature = c.json("repo_commit", json!({"repo": repo, "branch": "feature", "message": "f", "changes": [{"path": "f", "content": "f\n"}]}));
    assert_eq!(feature["parent"], second["sha"]);
    let fix = c.json("repo_commit", json!({"repo": repo, "branch": "fix", "message": "x", "changes": [{"path": "x", "content": "x\n"}], "base": first["sha"]}));
    assert_eq!(fix["parent"], first["sha"]);
    let log = c.json(
        "repo_log",
        json!({"repo": repo, "rev": "feature", "limit": 1}),
    );
    assert_eq!(log[0]["author"]["name"], s.account.handle.as_str());

    // Branches are made and deleted without a commit.
    let develop = c.json("branch_create", json!({"repo": repo, "name": "develop"}));
    assert_eq!(develop["sha"], second["sha"]);
    let old = c.json(
        "branch_create",
        json!({"repo": repo, "name": "old", "from": first["sha"]}),
    );
    assert_eq!(old["sha"], first["sha"]);
    c.json("branch_delete", json!({"repo": repo, "name": "old"}));
    c.json(
        "branch_create",
        json!({"repo": repo, "name": "gone", "from": "main"}),
    );
    c.json("branch_delete", json!({"repo": repo, "name": "gone"}));
    // A deleted branch can be made again.
    c.json("branch_create", json!({"repo": repo, "name": "gone"}));
    c.json("branch_delete", json!({"repo": repo, "name": "gone"}));
    let refs_now = c.json("repo_refs", json!({"repo": repo}))["refs"].to_string();
    assert!(
        refs_now.contains("develop") && !refs_now.contains("refs/heads/old"),
        "{refs_now}"
    );
    for (tool, args, why) in [
        (
            "branch_create",
            json!({"repo": repo, "name": "develop"}),
            "already has",
        ),
        (
            "branch_create",
            json!({"repo": repo, "name": "y", "from": "nope"}),
            "no commit or branch",
        ),
        (
            "branch_delete",
            json!({"repo": repo, "name": "old"}),
            "has no branch",
        ),
        (
            "branch_delete",
            json!({"repo": repo, "name": "main"}),
            "default branch",
        ),
    ] {
        let (text, err) = c.call(tool, args);
        assert!(err && text.contains(why), "{tool}: {text}");
    }

    // Tags are made and deleted as branches are, and never twice.
    let v1 = c.json("tag_create", json!({"repo": repo, "name": "v1"}));
    assert_eq!(v1["sha"], second["sha"]);
    let v0 = c.json(
        "tag_create",
        json!({"repo": repo, "name": "v0", "from": first["sha"]}),
    );
    assert_eq!(v0["sha"], first["sha"]);
    let refs_now = c.json("repo_refs", json!({"repo": repo}))["refs"].to_string();
    assert!(refs_now.contains("refs/tags/v1"), "{refs_now}");
    c.json("tag_delete", json!({"repo": repo, "name": "v0"}));
    for (tool, args, why) in [
        (
            "tag_create",
            json!({"repo": repo, "name": "v1"}),
            "already has a tag",
        ),
        (
            "tag_delete",
            json!({"repo": repo, "name": "v0"}),
            "has no tag",
        ),
    ] {
        let (text, err) = c.call(tool, args);
        assert!(err && text.contains(why), "{tool}: {text}");
    }

    let repos = c.json("repo_list", json!({"handle": s.account.handle}));
    assert_eq!(repos[0]["name"], "agentic");
    assert_eq!(repos[0]["description"], "made by a tool");
    let members = c.json("repo_members", json!({"repo": repo}));
    assert_eq!(members[0]["access"], "owner");
    let protect = |extra: Value| {
        let mut args = json!({"repo": repo, "branch": "main"});
        args.as_object_mut()
            .unwrap()
            .extend(extra.as_object().unwrap().clone());
        c.json("branch_protect", args)
    };
    let rule = |history| json!([{"branch": "main", "history": history}]);
    assert_eq!(protect(json!({})), rule("linear"));
    assert_eq!(protect(json!({"merges": true})), rule("merges"));
    assert_eq!(protect(json!({"undo": true})), json!([]));
    // What its runners report: here the owner runs its own. Naming none,
    // it has nothing to show or to ask.
    for (tool, args) in [
        ("run_list", json!({"repo": repo})),
        ("run_rerun", json!({"repo": repo, "ref": "refs/heads/main"})),
    ] {
        let (text, err) = c.call(tool, args);
        assert!(err && text.contains("names no runners"), "{tool}: {text}");
    }
    assert_eq!(c.json("runner_list", json!({"repo": repo})), json!([]));
    let handle = s.account.handle.clone();
    let named = c.json("runner_add", json!({"repo": repo, "handle": handle}));
    assert_eq!(named, json!([{"did": s.account.did, "handle": handle}]));
    let named = c.json("runner_remove", json!({"repo": repo, "handle": handle}));
    assert_eq!(named, json!([]));
    // Agents likewise.
    assert_eq!(c.json("agent_list", json!({"repo": repo})), json!([]));
    let named = c.json("agent_add", json!({"repo": repo, "handle": handle}));
    assert_eq!(named, json!([{"did": s.account.did, "handle": handle}]));
    let named = c.json("agent_remove", json!({"repo": repo, "handle": handle}));
    assert_eq!(named, json!([]));
    c.json("runner_add", json!({"repo": repo, "handle": handle}));
    // Its minutes: none counted, then what the runner filed for its owner.
    let counted = c.json("runner_minutes", json!({"repo": repo}));
    let none = json!([{"runner": s.account.did, "handle": handle, "counted": null}]);
    assert_eq!(counted, none);
    let minutes = json!({"$type": "dev.knotless.minutes", "minutes": 12, "allowance": 2000, "updatedAt": "2026-10-25T00:00:00Z"});
    s.put_record("dev.knotless.minutes", &s.account.did, minutes);
    let counted = c.json("runner_minutes", json!({"repo": repo}));
    assert_eq!(counted[0]["counted"]["minutes"], 12, "{counted}");
    assert_eq!(counted[0]["counted"]["allowance"], 2000, "{counted}");
    let key = s.record("dev.knotless.repo", "agentic")["key"]
        .as_str()
        .unwrap()
        .to_string();
    let commit = "a".repeat(40);
    let rkey =
        knotless::keys::check_rkey(&s.account.did, &key, "refs/heads/main", &commit, None, "ci");
    let picture = s.upload_blob(b"GIF89a", "image/gif");
    s.put_record("dev.knotless.check", &rkey, json!({
        "$type": "dev.knotless.check", "repo": {"uri": format!("at://{}/dev.knotless.repo/agentic", s.account.did), "key": key},
        "ref": "refs/heads/main", "commit": "a".repeat(40), "workflow": "ci", "status": "success",
        "outputs": [
            {"$type": "dev.knotless.check#image", "image": picture, "alt": "home 2 after"},
            {"$type": "dev.knotless.check#trace", "name": "trace.zip"},
        ],
        "startedAt": "2026-10-21T00:00:00.000Z",
    }));
    let checks = c.json(
        "run_list",
        json!({"repo": repo, "ref": "refs/heads/main", "log": true}),
    );
    assert_eq!(checks[0]["status"], "success");
    // It has no log to give.
    assert!(checks[0].get("logText").is_none(), "{checks}");
    assert_eq!(checks[0]["runner"], s.account.did.as_str());
    // With its pictures, each named, as images to look at; an output of a
    // kind it does not know left out.
    let params = CallToolRequestParams::new("run_list".to_string()).with_arguments(
        json!({"repo": repo, "images": true})
            .as_object()
            .unwrap()
            .clone(),
    );
    let res = c.rt.block_on(c.peer.call_tool(params)).unwrap();
    assert_eq!(res.content.len(), 3);
    assert_eq!(res.content[1].as_text().unwrap().text, "ci: home 2 after");
    let image = res.content[2].as_image().unwrap();
    assert_eq!(
        (image.data.as_str(), image.mime_type.as_str()),
        ("R0lGODlh", "image/gif")
    );
    let none = "b".repeat(40);
    let (text, err) = c.call("run_list", json!({"repo": repo, "commit": none, "wait": 1}));
    assert!(err, "{text}");
    assert!(
        text.contains(&format!("no checks of commit {none} after 1s")),
        "{text}"
    );
    let (text, err) = c.call("run_list", json!({"repo": repo, "commit": "main"}));
    assert!(err && text.contains("a commit is its hex ID"), "{text}");
    let asked = c.json("run_rerun", json!({"repo": repo, "ref": "refs/heads/main"}));
    let asked = asked["asked"].as_str().unwrap();
    assert!(asked.contains("/dev.knotless.rerun/"), "{asked}");
    // Or one workflow at a ref, with variables.
    let one = json!({"repo": repo, "ref": "refs/heads/main", "workflow": "scenarios", "env": {"TRACKS": "team"}});
    let asked = c.json("run_rerun", one);
    let rkey = asked["asked"].as_str().unwrap().rsplit('/').next().unwrap();
    let rerun = s.record("dev.knotless.rerun", rkey);
    assert_eq!(rerun["workflow"], "scenarios");
    assert_eq!(rerun["env"], json!([{"name": "TRACKS", "value": "team"}]));
    // Or to cancel what a ref or a pull has going, one workflow's or all.
    let off = json!({"repo": repo, "ref": "main", "workflow": "deploy"});
    let asked = c.json("run_cancel", off);
    let rkey = asked["asked"].as_str().unwrap().rsplit('/').next().unwrap();
    let cancel = s.record("dev.knotless.cancel", rkey);
    assert_eq!(
        (&cancel["ref"], &cancel["workflow"]),
        (&json!("refs/heads/main"), &json!("deploy"))
    );
    let (text, err) = c.call("run_cancel", json!({"repo": repo}));
    assert!(err && text.contains("name one ref or one pull"), "{text}");

    // The workflows at a ref, and what runs each there: it has none.
    let listed = c.json("workflow_list", json!({"repo": repo}));
    assert_eq!(listed, json!({"ref": "refs/heads/main", "workflows": []}));

    // Renamed, it answers to both names.
    let refs = c.json("repo_refs", json!({"repo": repo}));
    let renamed = c.json("repo_rename", json!({"repo": repo, "name": "agentic2"}));
    let moved = format!("knotless://{}/agentic2", s.account.handle);
    assert_eq!(renamed["url"], moved);
    assert_eq!(
        c.json("repo_refs", json!({"repo": repo}))["refs"],
        refs["refs"]
    );
    assert_eq!(
        c.json("repo_refs", json!({"repo": moved}))["refs"],
        refs["refs"]
    );
    // Its description dropped and its default branch named, as `knotless
    // describe` does, and its packs folded.
    let links = json!([{"url": "https://agentic.example", "title": "Site"}]);
    let topics = json!([{"name": "agents"}]);
    let described = json!({"repo": moved, "description": "", "links": links, "topics": ["agents"], "default_branch": "main"});
    let described = c.json("repo_edit", described);
    assert_eq!(
        described,
        json!({"description": null, "links": links, "topics": topics, "defaultBranch": "main"})
    );
    assert!(
        s.record("dev.knotless.repo", "agentic2")
            .get("description")
            .is_none()
    );
    let compacted = c.json("repo_compact", json!({ "repo": moved }));
    assert!(compacted["before"].as_u64().unwrap() >= 2, "{compacted}");
    assert!(compacted["removed"].is_u64() && compacted["claims"].is_u64());

    // Errors come back as tool errors, for the agent to read.
    for (tool, args) in [
        ("repo_read", json!({"repo": repo, "path": "nope"})),
        (
            "repo_read",
            json!({"repo": repo, "path": "README.md", "rev": "--all"}),
        ),
        ("repo_tree", json!({"repo": "not a repo"})),
        (
            "repo_tree",
            json!({"repo": format!("{}/missing", s.account.handle)}),
        ),
        (
            "repo_refs",
            json!({"repo": format!("{}/missing", s.account.handle)}),
        ),
        (
            "repo_storage",
            json!({"repo": format!("{}/missing", s.account.handle)}),
        ),
        ("repo_search", json!({"repo": repo, "pattern": ""})),
        ("repo_log", json!({"repo": repo, "rev": "-x"})),
        (
            "repo_blame",
            json!({"repo": repo, "path": "README.md", "rev": "-x"}),
        ),
        (
            "repo_diff",
            json!({"repo": repo, "base": "-x", "head": "main"}),
        ),
        ("repo_list", json!({"handle": "no-such-handle.test"})),
        (
            "repo_members",
            json!({"repo": format!("{}/missing", s.account.handle)}),
        ),
        (
            "repo_share",
            json!({"repo": repo, "handle": s.account.handle}),
        ),
        (
            "branch_protect",
            json!({"repo": repo, "branch": "main", "undo": true}),
        ),
        (
            "branch_protect",
            json!({"repo": format!("{}/missing", s.account.handle), "branch": "main"}),
        ),
        ("repo_rename", json!({"repo": "not a repo", "name": "x"})),
        ("repo_edit", json!({ "repo": moved })),
        ("repo_compact", json!({"repo": "not a repo"})),
        ("repo_delete", json!({"repo": moved, "confirm": "agentic"})),
        // With no appview, there is no gateway to assume.
        ("account_delegate", json!({})),
    ] {
        let (text, err) = c.call(tool, args.clone());
        assert!(err, "{tool} {args}: {text}");
    }
    // Deleted, once confirmed by its name.
    let deleted = c.json("repo_delete", json!({"repo": moved, "confirm": "agentic2"}));
    assert_eq!(deleted["deleted"], moved);
    assert!(s.record("dev.knotless.repo", "agentic2").is_null());
}

/// An agent deletes its account's knotless data: told what there is
/// first, then, confirmed by its handle, all of it. With no appview, there
/// is none to forget it.
/// What one call cost: the bytes the agent sent and was sent back, which
/// it pays for as tokens, and how long it took.
#[derive(Default, Clone, Copy)]
struct Cost {
    sent: usize,
    got: usize,
    took: std::time::Duration,
}

impl std::ops::Add for Cost {
    type Output = Cost;
    fn add(self, o: Cost) -> Cost {
        Cost {
            sent: self.sent + o.sent,
            got: self.got + o.got,
            took: self.took + o.took,
        }
    }
}

impl Client {
    /// The tool's text, and what the call cost.
    fn costed(&self, tool: &str, args: Value) -> (String, Cost) {
        let start = std::time::Instant::now();
        let text = self.ok(tool, args.clone());
        let cost = Cost {
            sent: args.to_string().len(),
            got: text.len(),
            took: start.elapsed(),
        };
        (text, cost)
    }
}

/// The bench for changing one line of a long file, kept as a test so it
/// cannot regress: the way an agent had to (read it all, send it all
/// back) against the way it can now (search with context, commit an
/// edit). Both land the same file; the second costs a small part of the
/// first, whatever the file's length. Its table is in docs/reference/mcp.md.
#[test]
fn an_agent_changes_a_line_of_a_long_file() {
    let s = logged_in();
    let c = Client::new(&s);
    let repo = format!("{}/long", s.account.handle);
    // About 130 KB, as the longest files in this repository are.
    let long: String = (0..1600)
        .map(|n| format!("    pub async fn item_{n:04}(&self) -> Result<u64> {{ self.get(\"item-{n:04}\", {n}).await }}\n"))
        .collect();
    let base = c.json(
        "repo_commit",
        json!({"repo": repo, "branch": "main", "message": "long", "changes": [
            {"path": "src/long.rs", "content": long},
            {"path": "README.md", "content": "item_0800 is here too\n"},
        ]}),
    );
    let old = "self.get(\"item-0800\", 800)";
    let new = "self.get(\"item-0800\", 801)";

    // Before: the whole file read, and the whole file sent back.
    let at = |branch: &str| json!({"repo": repo, "path": "src/long.rs", "rev": branch});
    let (read, r1) = c.costed("repo_read", at("main"));
    let content = read.replace(old, new);
    let (_, r2) = c.costed(
        "repo_commit",
        json!({"repo": repo, "branch": "whole", "message": "m",
        "base": base["sha"], "changes": [{"path": "src/long.rs", "content": content}]}),
    );
    let before = r1 + r2;

    // Now: the line found with what is around it, and only it sent back.
    let (found, n1) = c.costed(
        "repo_search",
        json!({"repo": repo, "pattern": "item_0800(", "path": "src", "context": 2}),
    );
    let runs: Value = serde_json::from_str(&found).unwrap();
    assert_eq!(
        (runs.as_array().unwrap().len(), &runs[0]["matches"]),
        (1, &json!([801]))
    );
    assert!(runs[0]["text"].as_str().unwrap().contains(old), "{runs}");
    let (_, n2) = c.costed("repo_commit", json!({"repo": repo, "branch": "edited", "message": "m",
        "base": base["sha"], "changes": [{"path": "src/long.rs", "edits": [{"old": old, "new": new}]}]}));
    let now = n1 + n2;

    assert_eq!(
        c.ok("repo_read", at("whole")),
        c.ok("repo_read", at("edited"))
    );
    let tokens = |c: Cost| (c.sent + c.got) / 4;
    println!(
        "changing a line of a {} byte file, two calls each:",
        long.len()
    );
    for (way, cost) in [("before", before), ("now", now)] {
        let (sent, got, ms) = (cost.sent, cost.got, cost.took.as_millis());
        println!(
            "  {way:6} sent {sent:>7} B  got {got:>7} B  ~{:>6} tokens  {ms:>5} ms",
            tokens(cost)
        );
    }
    let times = tokens(before) / tokens(now).max(1);
    println!("  {times}x fewer tokens");
    assert!(
        times >= 50,
        "edits cost {}, a whole file {}",
        tokens(now),
        tokens(before)
    );

    // A part of a file, and who last changed it.
    let part = c.json(
        "repo_read",
        json!({"repo": repo, "path": "src/long.rs", "start": 801, "end": 802}),
    );
    assert_eq!(
        (&part["start"], &part["end"], &part["lines"]),
        (&json!(801), &json!(802), &json!(1600))
    );
    assert!(
        part["text"]
            .as_str()
            .unwrap()
            .starts_with("    pub async fn item_0800("),
        "{part}"
    );
    let head = c.json(
        "repo_read",
        json!({"repo": repo, "path": "README.md", "end": 1}),
    );
    assert_eq!(head["text"], "item_0800 is here too\n");
    let blamed = c.json(
        "repo_blame",
        json!({"repo": repo, "path": "src/long.rs", "rev": "edited", "start": 801}),
    );
    assert_eq!(
        (&blamed[0]["start"], &blamed[0]["count"]),
        (&json!(801), &json!(1))
    );
    let everywhere = c.json(
        "repo_search",
        json!({"repo": repo, "pattern": "item_0800", "limit": 5}),
    );
    assert_eq!(everywhere.as_array().unwrap().len(), 2);

    // What an agent gets wrong comes back for it to put right.
    let edit = |old: &str| {
        json!({"repo": repo, "branch": "edited", "message": "m",
        "changes": [{"path": "src/long.rs", "edits": [{"old": old, "new": "x"}]}]})
    };
    for (args, says) in [
        (
            edit("item-0800\", 800)"),
            "edit 1 of src/long.rs: old is not in the file",
        ),
        (edit("pub async fn"), "old is in the file 1600 times"),
        (
            json!({"repo": repo, "branch": "edited", "message": "m",
            "changes": [{"path": "a", "content": "x", "edits": []}]}),
            "exactly one",
        ),
        (
            json!({"repo": repo, "path": "src/long.rs", "start": 0}),
            "no lines 0 to 1600",
        ),
    ] {
        let tool = if args.get("changes").is_some() {
            "repo_commit"
        } else {
            "repo_read"
        };
        let (text, err) = c.call(tool, args);
        assert!(err && text.contains(says), "{text}");
    }
}

#[test]
fn an_agent_deletes_its_knotless_data() {
    let s = logged_in();
    let c = Client::new(&s);
    c.json("repo_create", json!({"name": "gone", "runners": []}));
    let held = c.json("account_delete_data", json!({}));
    let repos = json!([{"name": "gone", "private": false, "collaborators": 0}]);
    assert_eq!(held["repos"], repos, "{held}");
    let (why, err) = c.call("account_delete_data", json!({"confirm": "nope"}));
    assert!(err && why.contains(&s.account.handle), "{why}");
    assert!(!s.record("dev.knotless.repo", "gone").is_null());
    let confirm = json!({"confirm": s.account.handle});
    let done = c.json("account_delete_data", confirm);
    assert!(done["deleted"].as_u64().unwrap() >= 1, "{done}");
    assert!(s.record("dev.knotless.repo", "gone").is_null());
    assert!(s.records("dev.knotless.repo").is_empty());
}

#[test]
fn an_agent_sets_its_profile() {
    let s = logged_in();
    let c = Client::new(&s);
    assert_eq!(c.json("account_profile", json!({})), json!({}));
    let set = c.json(
        "account_profile",
        json!({"bio": "Writes tools.", "pronouns": "they/them", "avatar": "iVBORw0KGgo=",
            "links": [{"url": "https://agent.example", "title": "Home"}]}),
    );
    assert_eq!(set["description"], "Writes tools.");
    assert_eq!(set["avatar"]["mimeType"], "image/png");
    let record = s.record("dev.knotless.profile", "self");
    assert_eq!(record["pronouns"], "they/them");
    assert_eq!(record["links"][0]["title"], "Home");
    let (text, err) = c.call("account_profile", json!({"avatar": "not base64!"}));
    assert!(err, "{text}");
    let left = c.json("account_profile", json!({"name": "Agent"}));
    assert_eq!(
        (&left["displayName"], &left["pronouns"]),
        (&json!("Agent"), &json!("they/them"))
    );
}

#[test]
fn a_template_asks_for_a_body() {
    let s = logged_in();
    let c = Client::new(&s);
    let repo = c_repo(&c.json("repo_create", json!({"name": "templated"})));
    // A new repository's default branch can be named, as with `knotless create`.
    let trunk = json!({"name": "trunked", "default_branch": "trunk"});
    let trunked = c_repo(&c.json("repo_create", trunk));
    let refs = c.json("repo_refs", json!({ "repo": trunked }));
    assert_eq!(refs["defaultBranch"], "trunk");
    let pull_md =
        "<!-- Title: what it does, under 70 characters. -->\n\n## What changes\n\n## Why\n";
    c.json(
        "repo_commit",
        json!({"repo": repo, "branch": "main", "message": "templates", "changes": [
            {"path": ".knotless/pull.md", "content": pull_md},
            {"path": ".knotless/issue.md", "content": "## What happened\n\n## What you expected\n"},
        ]}),
    );
    c.json("branch_create", json!({"repo": repo, "name": "change"}));
    let pull_template = |args: Value| c.json("pull_template", args)["template"].clone();
    assert_eq!(pull_template(json!({"repo": repo})), pull_md);
    assert_eq!(
        pull_template(json!({"repo": repo, "base": "change"})),
        pull_md
    );
    assert_eq!(
        pull_template(json!({"repo": repo, "base": "gone"})),
        Value::Null
    );
    let issue_template = c.json("issue_template", json!({"repo": repo}))["template"].clone();
    assert!(
        issue_template
            .as_str()
            .unwrap()
            .contains("What you expected")
    );

    let open = |body: Option<&str>| {
        let mut args = json!({"repo": repo, "base": "main", "head_repo": repo, "head_branch": "change", "title": "A change"});
        if let Some(b) = body {
            args["body"] = json!(b);
        }
        c.call("pull_create", args)
    };
    // No body, a blank one, or only the template's notes: the template
    // comes back to write the title and body from.
    let notes = "<!-- Title: what it does, under 70 characters. -->\n";
    for body in [None, Some("  \n"), Some(notes)] {
        let (text, err) = open(body);
        assert!(
            err && text.contains("title and body") && text.contains(pull_md),
            "{text}"
        );
    }
    // The notes copied in are left out, as forge's tests show.
    let (text, err) = open(Some(&format!("{notes}\n## What changes\n\nA line.\n")));
    assert!(!err, "{text}");
    // A body with none of the template's sections is refused, naming them;
    // one with any of them, at any level, goes in.
    let (text, err) = open(Some("Just prose, as before."));
    assert!(
        err && text.contains("none of its sections (what changes, why)"),
        "{text}"
    );
    let (text, err) = c.call("issue_create", json!({"repo": repo, "title": "Broken"}));
    assert!(
        err && text.contains("has no body") && text.contains("## What you expected"),
        "{text}"
    );
    c.json(
        "issue_create",
        json!({"repo": repo, "title": "Broken", "body": "### what happened\n\nIt <!-- broke -->."}),
    );
}

#[test]
fn sharing_from_an_agent() {
    if !net().spaces {
        eprintln!("skipped: the PDS is not on the spaces alpha");
        return;
    }
    let s = logged_in();
    let c = Client::new(&s);
    let created = c.json("repo_create", json!({"name": "secret", "private": true}));
    let repo = created["repo"].as_str().unwrap().to_string();
    c.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "m", "changes": [{"path": "a", "content": "a"}]}));
    assert_eq!(c.json("repo_refs", json!({"repo": repo}))["private"], true);
    // Its owner sees it listed, once, under the name it has now.
    let mine = |c: &Client| -> Vec<Value> {
        c.json("repo_list", json!({"handle": s.account.handle}))
            .as_array()
            .unwrap()
            .iter()
            .filter(|r| r["private"] == true)
            .cloned()
            .collect()
    };
    assert_eq!(mine(&c)[0]["name"], "secret");
    c.json("repo_rename", json!({"repo": repo, "name": "hidden"}));
    let listed = mine(&c);
    assert_eq!(listed.len(), 1, "{listed:?}");
    assert_eq!(listed[0]["name"], "hidden");
    c.json(
        "repo_rename",
        json!({"repo": format!("{}/hidden", s.account.handle), "name": "secret"}),
    );
    let reader = logged_in();
    let other = reader.account.clone();
    let members = c.json("repo_share", json!({"repo": repo, "handle": other.handle}));
    assert_eq!(
        members[1],
        json!({"did": other.did, "handle": other.handle, "access": "read"})
    );
    // A reader may not list the others.
    let (text, err) = Client::new(&reader).call("repo_members", json!({"repo": repo}));
    assert!(err && text.contains("owner can list"), "{text}");
    // Read-only, logged in as the reader, it reads the repository all the
    // same: an agent that must change nothing reads what its account may.
    let read_only = Client::of(knotless_mcp::Server::new(ctx(&reader)).read_only());
    assert_eq!(
        read_only.ok("repo_read", json!({"repo": repo, "path": "a"})),
        "a"
    );
    let members = c.json(
        "repo_share",
        json!({"repo": repo, "handle": other.handle, "undo": true}),
    );
    assert_eq!(members.as_array().unwrap().len(), 1);
}

#[test]
fn nobody_logged_in() {
    let mut s = Sandbox::new();
    s.set("KNOTLESS_PASSWORD", "");
    let c = Client::new(&s);
    let (text, err) = c.call("repo_create", json!({"name": "x"}));
    assert!(err && text.contains("not logged in"), "{text}");

    // An identifier and password in the environment act as that account.
    let mut s = Sandbox::new();
    let handle = s.account.handle.clone();
    s.set("KNOTLESS_IDENTIFIER", &handle);
    let c = Client::new(&s);
    let created = c.json("repo_create", json!({"name": "from-env"}));
    assert_eq!(created["repo"], format!("{handle}/from-env"));
}

#[test]
fn an_old_version_is_refused_and_a_new_one_told_of() {
    let mut s = Sandbox::new();
    let behind = knotless::update::Known {
        checked: 0,
        latest: Some("999.0.0".into()),
        minimum: Some("999.0.0".into()),
        reason: Some("Compaction loses objects.".into()),
    };
    let mine = json!({"handle": s.account.handle});
    let (said, err) = Client::knowing(&s, &behind).call("repo_list", mine.clone());
    assert!(err && said.contains("Compaction loses objects."), "{said}");
    // Its resources too, however well formed the URI.
    let file = format!("knotless://{}/x/file/main/a", s.account.handle);
    let refused = Client::knowing(&s, &behind).read(&file).unwrap_err();
    assert!(
        refused.message.contains("Compaction loses objects."),
        "{refused:?}"
    );

    // Told to go on anyway, it does, and says once that 999.0.0 is out.
    s.set("KNOTLESS_IGNORE_MINIMUM", "1");
    let c = Client::knowing(&s, &behind);
    let first = c.texts("repo_list", mine.clone());
    assert!(first.last().unwrap().starts_with("knotless 999.0.0 is out"));
    let again = c.texts("repo_list", mine);
    assert_eq!(again.len(), first.len() - 1);
}

/// A read-only server lists only the tools that read, each one the full
/// server has, and runs none of the others.
#[test]
fn a_read_only_server_only_reads() {
    let s = Sandbox::new();
    let names = |c: &Client| -> Vec<String> {
        let tools = c.rt.block_on(c.peer.list_all_tools()).unwrap();
        tools.into_iter().map(|t| t.name.to_string()).collect()
    };
    let all = names(&Client::new(&s));
    let reader = Client::of(knotless_mcp::Server::new(ctx(&s)).read_only());
    let mut read = names(&reader);
    read.sort();
    let mut reads: Vec<String> = knotless_mcp::READS.iter().map(|t| t.to_string()).collect();
    reads.sort();
    assert_eq!(read, reads);
    assert!(reads.iter().all(|t| all.contains(t)), "{reads:?}");
    assert!(all.contains(&"repo_commit".to_string()));
    let mine = json!({"repo": format!("{}/nothing", s.account.handle), "branch": "main", "message": "m", "changes": []});
    let params =
        CallToolRequestParams::new("repo_commit").with_arguments(mine.as_object().unwrap().clone());
    let refused = reader.rt.block_on(reader.peer.call_tool(params));
    assert!(refused.is_err(), "{refused:?}");
    reader.ok("repo_list", json!({"handle": s.account.handle}));
}

#[test]
fn the_binary_speaks_mcp_on_stdio() {
    use std::io::{BufRead, Write};
    let s = Sandbox::new();
    let mut child = s
        .command(env!("CARGO_BIN_EXE_knotless-mcp"), s.dir.path())
        .stdin(std::process::Stdio::piped())
        .stdout(std::process::Stdio::piped())
        .spawn()
        .unwrap();
    let mut stdin = child.stdin.take().unwrap();
    writeln!(
        stdin,
        "{}",
        json!({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {
            "protocolVersion": "2025-06-18", "capabilities": {},
            "clientInfo": {"name": "t", "version": "0"}}})
    )
    .unwrap();
    let mut line = String::new();
    std::io::BufReader::new(child.stdout.take().unwrap())
        .read_line(&mut line)
        .unwrap();
    let res: Value = serde_json::from_str(&line).unwrap();
    assert_eq!(res["result"]["serverInfo"]["name"], "knotless");
    drop(stdin);
    assert!(child.wait().unwrap().success());

    // Read-only, it says hello the same; it takes no other flag.
    let mut child = s
        .command(env!("CARGO_BIN_EXE_knotless-mcp"), s.dir.path())
        .arg("--read-only")
        .stdin(std::process::Stdio::piped())
        .stdout(std::process::Stdio::piped())
        .spawn()
        .unwrap();
    let mut stdin = child.stdin.take().unwrap();
    writeln!(
        stdin,
        "{}",
        json!({"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {
            "protocolVersion": "2025-06-18", "capabilities": {},
            "clientInfo": {"name": "t", "version": "0"}}})
    )
    .unwrap();
    let mut line = String::new();
    std::io::BufReader::new(child.stdout.take().unwrap())
        .read_line(&mut line)
        .unwrap();
    assert!(line.contains("\"knotless\""), "{line}");
    drop(stdin);
    assert!(child.wait().unwrap().success());
    let out = s
        .command(env!("CARGO_BIN_EXE_knotless-mcp"), s.dir.path())
        .arg("--bogus")
        .output()
        .unwrap();
    assert_eq!(out.status.code(), Some(2));

    // A client that leaves before it says hello is an error.
    let out = s
        .command(env!("CARGO_BIN_EXE_knotless-mcp"), s.dir.path())
        .stdin(std::process::Stdio::null())
        .output()
        .unwrap();
    assert!(!out.status.success());
}

/// An appview following the PDS, for listing public repositories' pulls
/// and issues.
/// It takes reports too, from the accounts `operators` names.
/// Its OAuth callback is on an https proxy in front of it, which the
/// returned `TlsProxy` keeps up.
fn appview(rt: &tokio::runtime::Runtime, operators: &str) -> (String, Sandbox, TlsProxy) {
    let mut s = Sandbox::new();
    s.set("KNOTLESS_ADMIN_DIDS", operators);
    let listener = rt
        .block_on(tokio::net::TcpListener::bind("127.0.0.1:0"))
        .unwrap();
    let base = format!("http://localhost:{}", listener.local_addr().unwrap().port());
    let index = knotless_serve::index::Index::open(&s.path("index.db")).unwrap();
    let proxy = tls_proxy(listener.local_addr().unwrap().port());
    let mut gateway = knotless_serve::gateway::Gateway::new(&base).unwrap();
    gateway.oauth_url = proxy.url.clone();
    let mut app = knotless_serve::App::build(
        ctx(&s),
        std::time::Duration::ZERO,
        Some(gateway),
        Some(index),
    );
    // It keeps its logs, for its operators to read.
    let logs = knotless_serve::logs::Logs::open(&s.path("logs.db"), knotless_serve::logs::KEEP);
    std::sync::Arc::get_mut(&mut app).unwrap().logs = Some(std::sync::Arc::new(logs.unwrap()));
    let router = knotless_serve::router(app.clone());
    rt.spawn(async move { axum::serve(listener, router).await.unwrap() });
    rt.spawn(knotless_serve::firehose::watch(
        app,
        net().pds.replace("http://", "ws://"),
    ));
    (base, s, proxy)
}

#[test]
fn agents_fork_review_and_merge() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let (base, _appview, _proxy) = appview(&rt, "");
    let mut owner = logged_in();
    owner.set("KNOTLESS_APPVIEW", &base);
    // Delegating is approved in the browser.
    let browser = browser(&owner.account, "");
    owner.set("KNOTLESS_BROWSER", &browser);
    // The appview is a gateway too, at a did:web served over http.
    owner.set("KNOTLESS_DID_WEB_SCHEME", "http");
    let mut contrib = logged_in();
    contrib.set("KNOTLESS_APPVIEW", &base);
    contrib.set("KNOTLESS_DID_WEB_SCHEME", "http");
    let (o, c) = (Client::new(&owner), Client::new(&contrib));

    let repo = c_repo(&o.json("repo_create", json!({"name": "reviewed"})));
    // Its owner gives its runner a secret, sealed to the key it publishes,
    // and lists it, never its value, then takes it back.
    let dir = tempfile::tempdir().unwrap();
    let keys = knotless::sealed::RunnerKeys::open_or_make(&dir.path().join("k.json")).unwrap();
    let nsid = knotless::sealed::KEY_NSID;
    let key = json!({"$type": nsid, "key": keys.public().did_key(), "createdAt": "2026-10-29T00:00:00.000Z"});
    contrib.put_record(nsid, knotless::sealed::KEY_RKEY, key);
    o.json(
        "runner_add",
        json!({"repo": repo, "handle": contrib.account.handle}),
    );
    let set = json!({"repo": repo, "name": "TOKEN", "value": "v4lue", "refs": ["refs/heads/main"]});
    let listed = o.json("secret_set", set);
    assert_eq!(listed[0]["name"], "TOKEN", "{listed}");
    assert_eq!(o.json("secret_list", json!({"repo": repo})), listed);
    assert_eq!(listed[0]["refs"], json!([{"pattern": "refs/heads/main"}]));
    assert!(listed[0].get("sealed").is_none(), "{listed}");
    let gone = o.json("secret_remove", json!({"repo": repo, "name": "TOKEN"}));
    assert_eq!(gone, json!([]));
    o.json(
        "runner_remove",
        json!({"repo": repo, "handle": contrib.account.handle}),
    );
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "start", "changes": [{"path": "a", "content": "a\n"}]}));
    let fork = c_repo(&c.json("repo_fork", json!({"repo": repo})));
    assert_eq!(fork, format!("{}/reviewed", contrib.account.handle));
    let change = c.json("repo_commit", json!({"repo": fork, "branch": "main", "message": "b", "changes": [{"path": "b", "content": "b\n"}]}));

    // A collaborator pushes through a gateway, the owner's writes
    // delegated to it: sharing for writing first delegates them to the
    // appview, and says so after who may write.
    let (text, err) = c.call("branch_create", json!({"repo": repo, "name": "theirs"}));
    assert!(err && text.contains("only its owner can"), "{text}");
    let shared = o.texts(
        "repo_share",
        json!({"repo": repo, "handle": contrib.account.handle, "write": true}),
    );
    let members: Value = serde_json::from_str(&shared[0]).unwrap();
    assert_eq!(members[1]["access"], "write", "{members}");
    assert_eq!(shared.len(), 2, "{shared:?}");
    let first = "Delegated your writes to the gateway did:web:localhost%3A";
    assert!(shared[1].starts_with(first), "{shared:?}");
    // Delegated to already, it shares at once; another gateway may be
    // named.
    let shared = o.texts(
        "repo_share",
        json!({"repo": repo, "handle": contrib.account.handle, "write": true}),
    );
    assert_eq!(shared.len(), 1, "{shared:?}");
    let gateway = o.json("account_delegate", json!({}))["delegated"].clone();
    assert!(
        gateway
            .as_str()
            .unwrap()
            .starts_with("did:web:localhost%3A"),
        "{gateway}"
    );
    o.json("account_delegate", json!({"gateway": gateway}));
    c.json("branch_create", json!({"repo": repo, "name": "theirs"}));
    c.json("branch_delete", json!({"repo": repo, "name": "theirs"}));
    o.json(
        "repo_share",
        json!({"repo": repo, "handle": contrib.account.handle, "undo": true}),
    );

    let pull = c.json("pull_create", json!({"repo": repo, "base": "main", "head_repo": fork, "head_branch": "main", "title": "Add b", "body": "small"}));
    let pull = pull["uri"].as_str().unwrap().to_string();
    let issue = c.json("issue_create", json!({"repo": repo, "title": "Missing c"}))["uri"]
        .as_str()
        .unwrap()
        .to_string();
    let listed = |state: &str| -> Vec<Value> {
        o.json(
            "pull_list",
            json!({"repo": repo, "query": format!("state:{state}")}),
        )
        .as_array()
        .unwrap()
        .clone()
    };
    wait_until(|| listed("open").len() == 1);
    // Authors come with their handles.
    assert_eq!(listed("open")[0]["handle"], contrib.account.handle.as_str());
    wait_until(|| {
        let pulls = o.json("pull_list", json!({"repo": repo}));
        let issues = o.json("issue_list", json!({"repo": repo}));
        pulls.as_array().unwrap().len() + issues.as_array().unwrap().len() == 2
    });
    // A query filters them, as GitHub's search does.
    let missing = o.json(
        "issue_list",
        json!({"repo": repo, "query": "state:open missing"}),
    );
    assert_eq!(missing.as_array().unwrap().len(), 1, "{missing}");
    assert_eq!(missing[0]["uri"], issue.as_str());

    o.json(
        "comment_add",
        json!({"repo": repo, "uri": pull, "body": "good", "approve": true}),
    );
    let (text, err) = o.call(
        "comment_add",
        json!({"repo": repo, "uri": pull, "body": "?", "approve": true, "changes": true}),
    );
    assert!(err, "{text}");
    // Its author comments on it, and reviews nothing of their own.
    let mine = json!({"repo": repo, "uri": pull, "body": "mine", "approve": true});
    let (text, err) = c.call("comment_add", mine);
    assert!(err && text.contains("your own pull"), "{text}");
    wait_until(|| {
        o.json("pull_show", json!({"repo": repo, "uri": pull}))["comments"]
            .as_array()
            .unwrap()
            .len()
            == 1
    });
    let shown = o.json("pull_show", json!({"repo": repo, "uri": pull}));
    assert_eq!(shown["item"]["handle"], contrib.account.handle.as_str());
    assert_eq!(shown["item"]["reviews"].as_array().unwrap().len(), 1);

    // The pull's author points it at the head branch it already names.
    assert_eq!(
        c.json(
            "pull_retarget",
            json!({"repo": repo, "uri": pull, "head": "main"})
        )["retargeted"],
        pull
    );
    let (text, err) = o.call(
        "pull_retarget",
        json!({"repo": repo, "uri": pull, "base": "nope"}),
    );
    assert!(err, "{text}");

    // Its author changes what a pull or a comment says, and takes a
    // comment back.
    let edited = c.json(
        "pull_edit",
        json!({"repo": repo, "uri": pull, "title": "Add b, please", "body": format!("smaller, for {issue}")}),
    );
    assert_eq!(edited["edited"], pull);
    // Made a draft and ready again, but not both at once.
    let (text, err) = c.call(
        "pull_edit",
        json!({"repo": repo, "uri": pull, "draft": true, "ready": true}),
    );
    assert!(err && text.contains("not both"), "{text}");
    c.json(
        "pull_edit",
        json!({"repo": repo, "uri": pull, "draft": true}),
    );
    c.json(
        "pull_edit",
        json!({"repo": repo, "uri": pull, "ready": true}),
    );
    let retitled = json!({"repo": repo, "uri": issue, "title": "Missing c, please"});
    assert_eq!(c.json("issue_edit", retitled)["edited"], issue);
    let said = c.json(
        "comment_add",
        json!({"repo": repo, "uri": pull, "body": "one more"}),
    )["uri"]
        .as_str()
        .unwrap()
        .to_string();
    // A picture shown after what it says, attached while it shows it.
    let png = {
        use base64::Engine;
        base64::engine::general_purpose::STANDARD.encode(b"\x89PNG\r\n\x1a\nshot")
    };
    let shot = json!([{"base64": png, "alt": "the page"}]);
    c.json(
        "comment_edit",
        json!({"repo": repo, "uri": said, "body": "see", "images": shot}),
    );
    let rkey = said.rsplit('/').next().unwrap();
    let record = contrib.record("dev.knotless.comment", rkey);
    assert!(
        record["body"]
            .as_str()
            .unwrap()
            .starts_with("see\n\n![the page](http"),
        "{record}"
    );
    assert_eq!(
        record["attachments"].as_array().unwrap().len(),
        1,
        "{record}"
    );
    let (text, err) = c.call(
        "pull_edit",
        json!({"repo": repo, "uri": pull, "images": shot}),
    );
    assert!(err && text.contains("go with a body"), "{text}");
    let broken = json!([{"base64": "not base64!", "alt": "x"}]);
    let (text, err) = c.call(
        "comment_add",
        json!({"repo": repo, "uri": pull, "body": "x", "images": broken}),
    );
    assert!(err, "{text}");
    c.json(
        "comment_edit",
        json!({"repo": repo, "uri": said, "body": "one more thing"}),
    );
    wait_until(|| {
        let shown = o.json("pull_show", json!({"repo": repo, "uri": pull}));
        let comments = shown["comments"].as_array().unwrap().clone();
        shown["item"]["title"] == "Add b, please"
            && shown["item"]["body"] == format!("smaller, for {issue}")
            && comments
                .iter()
                .any(|x| x["body"] == "one more thing" && x["updatedAt"].is_string())
    });
    // The issue it names says so.
    let shown = o.json("issue_show", json!({"repo": repo, "uri": issue}));
    assert_eq!(shown["mentionedBy"], json!([{"pull": pull}]), "{shown}");
    assert_eq!(
        c.json("comment_delete", json!({"repo": repo, "uri": said}))["deleted"],
        said
    );
    wait_until(|| {
        o.json("pull_show", json!({"repo": repo, "uri": pull}))["comments"]
            .as_array()
            .unwrap()
            .len()
            == 1
    });

    // Before merging: what it brings in, that it merges, and the review.
    let shown = o.json("pull_show", json!({"repo": repo, "uri": pull}));
    assert_eq!(shown["compare"]["mergeable"], "fast-forward");
    assert_eq!(shown["compare"]["head"], change["sha"]);
    assert_eq!(shown["compare"]["commits"].as_array().unwrap().len(), 1);
    assert_eq!(shown["comments"][0]["body"], "good");
    assert_eq!(shown["comments"][0]["verdict"], "approve");
    let review = &shown["item"]["reviews"][0];
    assert_eq!(
        (&review["by"], &review["verdict"]),
        (&json!(owner.account.did), &json!("approve"))
    );
    assert_eq!(review["commit"], change["sha"]);
    assert_eq!(
        shown["comments"][0]["handle"],
        owner.account.handle.as_str()
    );
    // A comment on its lines, answered in its thread, which its author
    // resolves.
    let lines = json!([{"path": "b", "line": 1, "side": "new", "body": "Why b?"}]);
    let wrote = o.json(
        "comment_add",
        json!({"repo": repo, "uri": pull, "body": "", "lines": lines}),
    );
    let on = wrote["uri"].as_str().unwrap().to_string();
    assert_eq!(wrote["written"], json!([on]));
    // A review sends at most a hundred.
    let many: Vec<Value> = (1..=101)
        .map(|n| json!({"path": "b", "line": n, "body": "And this"}))
        .collect();
    let (text, err) = o.call(
        "comment_add",
        json!({"repo": repo, "uri": pull, "body": "", "lines": many}),
    );
    assert!(err && text.contains("at most 100"), "{text}");
    c.json(
        "comment_add",
        json!({"repo": repo, "uri": on, "body": "Because"}),
    );
    c.json("comment_resolve", json!({"repo": repo, "uri": on}));
    let thread = || o.json("pull_show", json!({"repo": repo, "uri": pull}))["comments"].clone();
    let said = |c: &Value| c["reply"] == on.as_str();
    wait_until(|| thread().as_array().unwrap().iter().any(said));
    let comments = thread();
    let started = comments
        .as_array()
        .unwrap()
        .iter()
        .find(|c| c["uri"] == on.as_str());
    let started = started.unwrap();
    assert_eq!(
        (&started["line"]["path"], &started["resolved"]),
        (&json!("b"), &json!(true))
    );
    // Its answers stand as the thread does.
    let answer = comments.as_array().unwrap().iter().find(|c| said(c));
    assert_eq!(answer.unwrap()["resolved"], true);

    let diff = o.ok("pull_diff", json!({"repo": repo, "uri": pull}));
    // Each line numbered as the comment on it above took it: b's line 1,
    // on the new side, and none on the old.
    assert!(diff.contains("@@ -0,0 +1 @@\n  1 | +b\n"), "{diff}");
    // Asked for by path, the file's part of it is the same.
    let part = o.ok(
        "pull_diff",
        json!({"repo": repo, "uri": pull, "paths": ["b"]}),
    );
    assert!(part.contains("@@ -0,0 +1 @@\n  1 | +b\n"), "{part}");

    // Merged, it says how, and why its branch stays: it is in the fork.
    let merged = o.json("pull_merge", json!({"repo": repo, "uri": pull}));
    assert_ne!(merged["sha"], change["sha"]);
    assert_eq!(merged["method"], "merge");
    let kept = merged["kept"].as_str().unwrap();
    assert!(kept.starts_with("main is in another repository"), "{kept}");
    wait_until(|| listed("merged").len() == 1);
    let (text, err) = o.call("pull_merge", json!({"repo": repo, "uri": pull}));
    assert!(err, "{text}");
    // Merged, it compares as its merge brought it in, though its branch
    // moves on.
    c.json("repo_commit", json!({"repo": fork, "branch": "main", "message": "later", "changes": [{"path": "z", "content": "z\n"}]}));
    let shown = o.json("pull_show", json!({"repo": repo, "uri": pull}));
    let compared = &shown["compare"];
    assert_eq!(compared["mergeable"], "merged");
    // The merge commit, and the commit it brought in.
    assert_eq!(compared["head"], merged["sha"]);
    assert_eq!(compared["commits"].as_array().unwrap().len(), 2);
    // Merged, it reverts in a pull of its own, on a branch of its own.
    let reverted = o.json(
        "pull_revert",
        json!({"repo": repo, "uri": pull, "reason": "not yet"}),
    );
    let rkey = pull.rsplit('/').next().unwrap();
    assert_eq!(reverted["branch"], format!("revert/{rkey}"));
    assert!(
        reverted["pull"]
            .as_str()
            .unwrap()
            .contains("dev.knotless.pull")
    );
    let (text, err) = o.call("pull_revert", json!({"repo": repo, "uri": pull}));
    assert!(err && text.contains("has a branch"), "{text}");
    // The revert names what it undoes, and once it merges, that names it.
    let undo = reverted["pull"].as_str().unwrap();
    wait_until(|| listed("open").iter().any(|i| i["uri"] == undo));
    let shown = o.json("pull_show", json!({"repo": repo, "uri": undo}));
    assert_eq!(shown["item"]["reverts"], pull.as_str());
    assert!(shown["item"].get("revertedBy").is_none(), "{shown}");
    o.json("pull_merge", json!({"repo": repo, "uri": undo}));
    wait_until(|| {
        let shown = o.json("pull_show", json!({"repo": repo, "uri": pull}));
        shown["item"]["revertedBy"] == undo
    });

    // A pull that conflicts says where.
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "mine", "changes": [{"path": "a", "content": "owner\n"}]}));
    c.json("repo_commit", json!({"repo": fork, "branch": "clash", "message": "theirs", "changes": [{"path": "a", "content": "contrib\n"}]}));
    let clash = c.json("pull_create", json!({"repo": repo, "base": "main", "head_repo": fork, "head_branch": "clash", "title": "Clash"}));
    let clash = clash["uri"].as_str().unwrap().to_string();
    let compared = &o.json("pull_show", json!({"repo": repo, "uri": clash}))["compare"];
    assert_eq!(compared["mergeable"], "conflict");
    assert_eq!(compared["conflicts"], json!(["a"]));
    let (text, err) = o.call("pull_merge", json!({"repo": repo, "uri": clash}));
    assert!(err && text.contains("conflicts in a"), "{text}");
    // Its branch is in the fork: the fork's owner brings it up to date.
    let (text, err) = o.call("pull_update_branch", json!({"repo": repo, "uri": clash}));
    assert!(err && text.contains("in another repository"), "{text}");
    // Merged, a pull's branch is not brought up to date.
    let (text, err) = o.call("pull_update_branch", json!({"repo": repo, "uri": pull}));
    assert!(err && text.contains("only an open pull"), "{text}");
    // One here is, the lines both sides added at one place kept, main's first.
    o.json("branch_create", json!({"repo": repo, "name": "notes"}));
    o.json("repo_commit", json!({"repo": repo, "branch": "notes", "message": "n", "changes": [{"path": "a", "content": "owner\nnotes\n"}]}));
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "m", "changes": [{"path": "a", "content": "owner\nmain\n"}]}));
    let notes = o.json("pull_create", json!({"repo": repo, "base": "main", "head_repo": repo, "head_branch": "notes", "title": "Notes"}));
    let notes = notes["uri"].as_str().unwrap().to_string();
    let updated = o.json("pull_update_branch", json!({"repo": repo, "uri": notes}));
    assert_eq!(updated["branch"], "notes");
    assert_eq!(updated["added"], json!(["a"]));
    let read = o.ok(
        "repo_read",
        json!({"repo": repo, "path": "a", "rev": "notes"}),
    );
    assert_eq!(read, "owner\nmain\nnotes\n");
    // One that touches other files merges cleanly though main moved on.
    c.json("repo_commit", json!({"repo": fork, "branch": "aside", "message": "c", "changes": [{"path": "c", "content": "c\n"}]}));
    let aside = c.json("pull_create", json!({"repo": repo, "base": "main", "head_repo": fork, "head_branch": "aside", "title": "Aside"}));
    let aside = aside["uri"].as_str().unwrap().to_string();
    let compared = &o.json("pull_show", json!({"repo": repo, "uri": aside}))["compare"];
    assert_eq!(compared["mergeable"], "clean");
    // One whose head the base holds already brings in nothing.
    o.json("branch_create", json!({"repo": repo, "name": "level"}));
    let level = o.json("pull_create", json!({"repo": repo, "base": "level", "head_repo": repo, "head_branch": "main", "title": "Level"}));
    let level = level["uri"].as_str().unwrap().to_string();
    let compared = &o.json("pull_show", json!({"repo": repo, "uri": level}))["compare"];
    assert_eq!(compared["mergeable"], "merged");
    assert_eq!(compared["commits"], json!([]));
    // Once main moves on, it merges, and main, the default branch, stays.
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "l", "changes": [{"path": "l", "content": "l\n"}]}));
    let merged = o.json("pull_merge", json!({"repo": repo, "uri": level}));
    let kept = merged["kept"].as_str().unwrap();
    assert!(kept.contains("the branch it merges into"), "{kept}");

    // Renaming a branch takes the pulls on it along.
    o.json("branch_create", json!({"repo": repo, "name": "develop"}));
    let onto = c.json("pull_create", json!({"repo": repo, "base": "develop", "head_repo": fork, "head_branch": "clash", "title": "Onto develop"}));
    let onto = onto["uri"].as_str().unwrap().to_string();
    wait_until(|| listed("open").iter().any(|i| i["uri"] == onto.as_str()));
    let renamed = o.json(
        "branch_rename",
        json!({"repo": repo, "name": "develop", "new_name": "next"}),
    );
    assert_eq!(renamed["retargeted"], json!([onto]));
    wait_until(|| {
        o.json("pull_show", json!({"repo": repo, "uri": onto}))["item"]["base"] == "next"
    });
    let (text, err) = o.call(
        "branch_rename",
        json!({"repo": repo, "name": "main", "new_name": "trunk"}),
    );
    assert!(err && text.contains("default branch"), "{text}");

    // A pull whose head is gone still shows, and says so.
    c.json("branch_delete", json!({"repo": fork, "name": "clash"}));
    let compared = &o.json("pull_show", json!({"repo": repo, "uri": clash}))["compare"];
    assert!(
        compared["error"]
            .as_str()
            .unwrap()
            .contains("has no branch clash"),
        "{compared}"
    );

    // An issue has nothing to compare.
    let shown = o.json("issue_show", json!({"repo": repo, "uri": issue}));
    assert!(shown.get("compare").is_none(), "{shown}");
    // The owner defines labels and puts them on; the issue's author may not.
    let bug = json!({"repo": repo, "name": "kind/bug", "color": "#d73a4a"});
    o.json("label_define", bug);
    let docs = json!({"repo": repo, "name": "kind/docs", "exclusive": true});
    let defined = o.json("label_define", docs);
    assert_eq!(defined[1]["exclusive"], true, "{defined}");
    assert_eq!(o.json("label_list", json!({"repo": repo})), defined);
    let both = json!({"repo": repo, "uri": issue, "labels": ["kind/bug", "kind/docs"]});
    let (text, err) = c.call("issue_label", both.clone());
    assert!(err, "{text}");
    assert_eq!(
        o.json("issue_label", both)["labels"],
        json!(["kind/bug", "kind/docs"])
    );
    let off = json!({"repo": repo, "uri": issue, "labels": ["kind/bug"], "undo": true});
    assert_eq!(o.json("issue_label", off)["labels"], json!(["kind/docs"]));
    // A pull takes labels the same way.
    let on_pull = json!({"repo": repo, "uri": clash, "labels": ["kind/bug"]});
    assert_eq!(o.json("pull_label", on_pull)["labels"], json!(["kind/bug"]));
    // The owner assigns it, and asks for a review of a pull besides its
    // author; the shown item names them.
    let them = contrib.account.handle.clone();
    let assigning = json!({"repo": repo, "uri": issue, "handles": [them]});
    let (text, err) = c.call("issue_assign", assigning.clone());
    assert!(err, "{text}");
    let assigned = o.json("issue_assign", assigning);
    assert_eq!(assigned["assignees"], json!([contrib.account.did]));
    // The shown issue names them once the appview hears of the assignment.
    let shown = || o.json("issue_show", json!({"repo": repo, "uri": issue}));
    wait_until(|| shown()["item"]["assignees"][0]["handle"] == them.as_str());
    let me = owner.account.handle.clone();
    let asking = json!({"repo": repo, "uri": clash, "handles": [me]});
    assert_eq!(
        o.json("pull_ask_review", asking.clone())["reviewers"],
        json!([owner.account.did])
    );
    let mut stop = asking.clone();
    stop["undo"] = json!(true);
    assert_eq!(o.json("pull_ask_review", stop)["reviewers"], json!([]));
    o.json("pull_ask_review", asking);
    let off = json!({"repo": repo, "uri": issue, "handles": [them], "undo": true});
    assert_eq!(o.json("issue_assign", off)["assignees"], json!([]));
    // A pull is assigned the same way.
    let to_pull = json!({"repo": repo, "uri": clash, "handles": [them]});
    assert_eq!(
        o.json("pull_assign", to_pull)["assignees"],
        json!([contrib.account.did])
    );
    // The owner asks for changes to it, then dismisses that review: the
    // shown pull says so, and its author may not.
    let review = json!({"repo": repo, "uri": clash, "body": "no", "changes": true});
    o.json("comment_add", review);
    let dismissing = json!({"repo": repo, "uri": clash, "reviewer": me, "reason": "moot"});
    let (text, err) = c.call("pull_dismiss_review", dismissing.clone());
    assert!(err, "{text}");
    let dismissal = o.json("pull_dismiss_review", dismissing)["uri"].clone();
    // The shown pull says so once the appview hears of the dismissal.
    let shown = || o.json("pull_show", json!({"repo": repo, "uri": clash}));
    wait_until(|| shown()["item"]["reviews"][0]["dismissed"] == dismissal);
    let shown = shown();
    let mine = &shown["item"]["reviews"][0];
    assert_eq!(
        (&mine["by"], &mine["dismissed"]),
        (&json!(owner.account.did), &dismissal)
    );
    let said = shown["comments"].as_array().unwrap();
    assert!(
        said.iter().any(|c| c["dismisses"] == mine["uri"]),
        "{shown}"
    );
    let gone = o.json("label_delete", json!({"repo": repo, "name": "kind/bug"}));
    assert_eq!(gone.as_array().unwrap().len(), 1, "{gone}");
    let bot = contrib.account.handle.clone();
    let named = o.json(
        "triager_add",
        json!({"repo": repo, "handle": bot, "scopes": ["kind"]}),
    );
    assert_eq!(named[0]["scopes"][0]["name"], "kind", "{named}");
    assert_eq!(o.json("triager_list", json!({"repo": repo})), named);
    let unnamed = o.json("triager_remove", json!({"repo": repo, "handle": bot}));
    assert_eq!(unnamed, json!([]));
    let closing = json!({"repo": repo, "uri": issue});
    assert_eq!(o.json("issue_close", closing.clone())["state"], "closed");
    assert_eq!(o.json("issue_reopen", closing)["state"], "open");
    let closing = json!({"repo": repo, "uri": clash});
    assert_eq!(o.json("pull_close", closing.clone())["state"], "closed");
    assert_eq!(o.json("pull_reopen", closing)["state"], "open");
    let (text, err) = o.call("comment_resolve", json!({"repo": repo, "uri": issue}));
    assert!(err, "{text}");
    // Queued, a pull waits for a runner to land it, and leaves when asked.
    let (text, err) = o.call(
        "pull_merge",
        json!({"repo": repo, "uri": aside, "queue": true}),
    );
    assert!(err && text.contains("names no runners"), "{text}");
    o.json(
        "runner_add",
        json!({"repo": repo, "handle": owner.account.handle}),
    );
    // Nor is there a queue until a rule of the branch turns it on.
    let (text, err) = o.call(
        "pull_merge",
        json!({"repo": repo, "uri": aside, "queue": true}),
    );
    assert!(
        err && text.contains("does not use the merge queue"),
        "{text}"
    );
    // Set to merge when its checks pass it says so, until cancelled.
    let auto = json!({"repo": repo, "uri": aside, "auto": true});
    let set = o.json("pull_merge", auto.clone());
    assert_eq!(set["autoMerge"], "set", "{set}");
    // Once the index has the record.
    wait_until(|| {
        let shown = o.json("pull_show", json!({"repo": repo, "uri": aside}));
        let said = shown["autoMerge"].as_str().unwrap_or_default();
        said.starts_with("merge when checks pass: set by")
    });
    let undo = json!({"repo": repo, "uri": aside, "auto": true, "undo": true});
    assert_eq!(o.json("pull_merge", undo)["autoMerge"], "cancelled");
    let on = json!({"repo": repo, "branch": "main", "merges": true, "queue": true});
    o.json("branch_protect", on);
    // Asked first, it would merge: it has no workflows to wait for. Its
    // branch is in the fork, so nothing goes with it.
    let checked = o.json(
        "pull_merge",
        json!({"repo": repo, "uri": aside, "check": true}),
    );
    assert_eq!(checked["state"], "clean", "{checked}");
    assert_eq!(checked["checks"], "none", "{checked}");
    assert_eq!(checked["method"], "merge", "{checked}");
    assert_eq!(checked.get("deletes"), None, "{checked}");
    let may = json!({"merge": true, "force": true, "queue": true, "autoMerge": false, "base": true, "head": false, "rerun": true});
    assert_eq!(checked["may"], may);
    let queued = o.json(
        "pull_merge",
        json!({"repo": repo, "uri": aside, "queue": true}),
    );
    assert_eq!(
        queued["queued"],
        json!({"base": "main", "position": 1, "of": 1})
    );
    wait_until(|| {
        o.json("queue_list", json!({"repo": repo}))
            .as_array()
            .unwrap()
            .len()
            == 1
    });
    let line = o.json("queue_list", json!({"repo": repo}));
    assert_eq!(line[0]["uri"], aside.as_str());
    assert_eq!(line[0]["queue"]["state"], "queued");
    let batches = o.json("run_list", json!({"repo": repo, "queue": "main"}));
    assert_eq!(batches, json!([]));
    let shown = o.json("pull_show", json!({"repo": repo, "uri": aside}));
    assert_eq!(shown["standing"]["said"], "Queued, 1st of 1", "{shown}");
    assert_eq!(shown["standing"]["place"]["position"], 1);
    assert!(shown["standing"]["batch"].is_null());
    assert_eq!(
        o.json("queue_leave", json!({"repo": repo, "uri": aside}))["left"],
        aside.as_str()
    );
    wait_until(|| o.json("queue_list", json!({"repo": repo})) == json!([]));
    let (text, err) = o.call("queue_leave", json!({"repo": repo, "uri": aside}));
    assert!(err && text.contains("not in the merge queue"), "{text}");
    // Into a branch that takes pulls only through the queue, a merge
    // queues it instead, saying why.
    let main = json!({"repo": repo, "branch": "main", "queue": true});
    let held = json!([{"branch": "main", "history": "linear", "queue": true}]);
    assert_eq!(o.json("branch_protect", main), held);
    assert_eq!(o.json("branch_rules", json!({"repo": repo})), held);
    let checked = o.json(
        "pull_merge",
        json!({"repo": repo, "uri": aside, "check": true}),
    );
    assert_eq!(checked["queueOnly"], true, "{checked}");
    let queued = o.json("pull_merge", json!({"repo": repo, "uri": aside}));
    assert_eq!(
        queued,
        json!({"queued": {"base": "main", "position": 1, "of": 1}, "why": "main takes pulls only through the merge queue"})
    );
    wait_until(|| o.json("queue_list", json!({"repo": repo})) != json!([]));
    o.json("queue_leave", json!({"repo": repo, "uri": aside}));
    wait_until(|| o.json("queue_list", json!({"repo": repo})) == json!([]));
    let unheld = json!({"repo": repo, "branch": "main", "undo": true});
    assert_eq!(o.json("branch_protect", unheld.clone()), json!([]));
    // A gate named by its handle is kept by its DID.
    let gate = json!({"repo": repo, "branch": "main", "gates": [contrib.account.handle]});
    let rules = o.json("branch_protect", gate);
    let gates = &rules[0]["reviews"]["gates"];
    assert_eq!(gates[0]["did"], contrib.account.did.as_str(), "{rules}");
    assert_eq!(o.json("branch_protect", unheld.clone()), json!([]));

    // Into a branch that asks for a review, an approval from someone who
    // may not write counts for nothing, and each answer says why.
    o.json("repo_commit", json!({"repo": repo, "branch": "mine", "message": "d", "changes": [{"path": "d", "content": "d\n"}]}));
    let them = contrib.account.handle.clone();
    let opened = json!({"repo": repo, "base": "main", "head_repo": repo, "head_branch": "mine", "title": "Add d", "reviewers": [them]});
    let mine = o.json("pull_create", opened)["uri"]
        .as_str()
        .unwrap()
        .to_string();
    let shown = || o.json("pull_show", json!({"repo": repo, "uri": mine}));
    // Asked to review it, they are waited on until they do.
    wait_until(|| shown()["item"]["reviewers"][0]["pending"] == true);
    let body = format!("Fine, @{}", owner.account.handle);
    let lines = json!([{"path": "d", "line": 1, "body": "Why d?"}]);
    let approval =
        json!({"repo": repo, "uri": mine, "body": body, "approve": true, "lines": lines});
    let asks = json!({"repo": repo, "branch": "main", "reviews": 1});
    o.json("branch_protect", asks);
    let approved = c.json("comment_add", approval);
    let note = approved["note"].as_str().unwrap();
    assert!(note.contains("does not count"), "{approved}");
    let review = approved["uri"].as_str().unwrap().to_string();
    // Asked at once, the check reads the review just written, not
    // waiting for the appview to hear of it.
    let at_once = c.json(
        "pull_merge",
        json!({"repo": repo, "uri": mine, "check": true}),
    );
    let counted = at_once["reviewsUncounted"].as_array();
    assert_eq!(counted.map(Vec::len), Some(1), "{at_once}");
    wait_until(|| shown()["comments"].as_array().unwrap().len() == 2);
    let s = shown();
    assert_eq!(s["item"]["draft"], false, "{s}");
    let asked = &s["item"]["reviewers"][0];
    assert_eq!(
        (&asked["did"], &asked["handle"], &asked["pending"]),
        (&json!(contrib.account.did), &json!(them), &json!(false))
    );
    // Its line comment says on which side and lines, as written or not,
    // and stands as its thread does; the review's own comment starts no
    // thread, so is not resolved or not.
    let (own, on_line) = (&s["comments"][0], &s["comments"][1]);
    assert_eq!(own.get("resolved"), None, "{own}");
    let at = json!({"path": "d", "side": "new", "line": 1, "startLine": 1});
    assert_eq!(
        (&on_line["line"], &on_line["resolved"]),
        (&at, &json!(false))
    );
    // A pull, draft or not, says so where pulls are listed too.
    let listed = o.json("pull_list", json!({"repo": repo, "query": "state:open"}));
    let listed = listed
        .as_array()
        .unwrap()
        .iter()
        .find(|i| i["uri"] == mine.as_str());
    assert_eq!(listed.unwrap()["draft"], false);
    let theirs = &s["item"]["reviews"][0];
    assert_eq!(theirs["handle"], them.as_str());
    assert_eq!(
        (&theirs["maintainer"], &theirs["outdated"]),
        (&json!(false), &json!(false))
    );
    let not = "only the owner's and collaborators' approvals count";
    assert_eq!(theirs["uncounted"], not);
    // The review's own comment names itself, as its line comment names
    // it; and says whom it mentions.
    for said in s["comments"].as_array().unwrap() {
        assert_eq!(said["review"], review.as_str(), "{said}");
    }
    let mention = &s["comments"][0]["facets"][0]["features"][0];
    assert_eq!(mention["did"], owner.account.did.as_str(), "{s}");
    // Asked first, it is blocked: the owner may merge it, but only by
    // force, and is told how, in tools.
    let checked = o.json(
        "pull_merge",
        json!({"repo": repo, "uri": mine, "check": true}),
    );
    assert_eq!(
        (
            &checked["state"],
            &checked["reviews"],
            &checked["may"]["merge"]
        ),
        (&json!("blocked"), &json!("blocked"), &json!(true)),
        "{checked}"
    );
    let uncounted = format!("@{them}'s approval does not count: {not}");
    assert_eq!(checked["reviewsUncounted"], json!([{"text": uncounted}]));
    let why = checked["reason"].as_str().unwrap();
    assert!(why.contains(&uncounted), "{why}");
    assert!(
        why.ends_with(
            "the owner, its author or not, merges past it with the pull_merge tool and force"
        ),
        "{why}"
    );
    let (text, err) = o.call("pull_merge", json!({"repo": repo, "uri": mine}));
    assert!(
        err && text.contains("the comment_add tool and approve"),
        "{text}"
    );
    // Someone who may not merge it is told so.
    let theirs = c.json(
        "pull_merge",
        json!({"repo": repo, "uri": mine, "check": true}),
    );
    assert_eq!(theirs["may"]["merge"], false);
    let why = theirs["reason"].as_str().unwrap();
    assert!(why.contains("; and you may not merge it"), "{why}");
    // The pull moves on: the approval is of an earlier head.
    o.json("repo_commit", json!({"repo": repo, "branch": "mine", "message": "e", "changes": [{"path": "e", "content": "e\n"}]}));
    wait_until(|| shown()["item"]["reviews"][0]["outdated"] == true);
    // Forced, it merges, saying how, and its branch goes with it.
    let merged = o.json(
        "pull_merge",
        json!({"repo": repo, "uri": mine, "force": true}),
    );
    assert_eq!(
        (&merged["method"], &merged["deleted"], &merged["kept"]),
        (&json!("squash"), &json!("mine"), &Value::Null),
        "{merged}"
    );
    // Its branch gone, its diff is what the merge brought in, numbered
    // as ever.
    wait_until(|| shown()["item"]["state"] == "merged");
    let diff = o.ok("pull_diff", json!({"repo": repo, "uri": mine}));
    assert!(diff.contains("+++ b/d\n"), "{diff}");
    assert!(diff.contains("@@ -0,0 +1 @@\n  1 | +e\n"), "{diff}");
    // Reviewed again, the review before stands for nothing now, and says
    // so; merged, no review of it is waited on.
    let again = json!({"repo": repo, "uri": mine, "body": "Still fine", "approve": true});
    c.json("comment_add", again);
    wait_until(|| shown()["comments"].as_array().unwrap().len() == 3);
    let s = shown();
    assert_eq!(s["comments"][0]["superseded"], true, "{s}");
    assert_eq!(s["comments"][2].get("superseded"), None, "{s}");
    assert_eq!(s["item"]["reviewers"][0]["pending"], false, "{s}");
    assert_eq!(o.json("branch_protect", unheld), json!([]));
    let (text, err) = o.call("queue_list", json!({"repo": "nobody.test/x"}));
    assert!(err, "{text}");

    // Archived, it is read only, to anyone; unarchived, it takes issues
    // again.
    let archived = o.json("repo_archive", json!({"repo": repo}));
    assert!(archived["archivedAt"].is_string(), "{archived}");
    let (text, err) = c.call("issue_create", json!({"repo": repo, "title": "Late"}));
    assert!(err && text.contains("is archived"), "{text}");
    let (text, err) = o.call("repo_archive", json!({"repo": repo}));
    assert!(err && text.contains("already archived"), "{text}");
    let back = o.json("repo_archive", json!({"repo": repo, "undo": true}));
    assert_eq!(back["archivedAt"], json!(null));

    // Offered to the contributor, withdrawn, offered again, and taken up.
    let them = contrib.account.handle.clone();
    o.json("repo_transfer", json!({"repo": repo, "to": them}));
    o.json("repo_transfer", json!({"repo": repo, "undo": true}));
    let offered = o.json(
        "repo_transfer",
        json!({"repo": repo, "to": format!("{them}/kept")}),
    );
    assert_eq!(offered["offeredTo"], format!("knotless://{them}/kept"));
    let moved = c.json("repo_accept", json!({"repo": repo}));
    assert_eq!(
        moved["url"],
        format!("knotless://{}/kept", contrib.account.did)
    );
    for (tool, args) in [
        ("repo_transfer", json!({"repo": "nobody.test/x", "to": "x"})),
        ("repo_transfer", json!({"repo": "nobody.test/x"})),
        (
            "repo_transfer",
            json!({"repo": "nobody.test/x", "to": "x", "undo": true}),
        ),
        ("repo_archive", json!({"repo": "nobody.test/x"})),
        ("repo_accept", json!({"repo": "nobody.test/x"})),
        ("repo_fork", json!({"repo": "nobody.test/x"})),
        (
            "pull_create",
            json!({"repo": repo, "base": "main", "head_repo": fork, "head_branch": "none", "title": "t"}),
        ),
        (
            "issue_create",
            json!({"repo": "nobody.test/x", "title": "t"}),
        ),
        ("pull_list", json!({"repo": "nobody.test/x"})),
        ("issue_list", json!({"repo": "nobody.test/x"})),
        ("label_list", json!({"repo": "nobody.test/x"})),
        ("pull_diff", json!({"repo": repo, "uri": issue})),
        (
            "pull_show",
            json!({"repo": repo, "uri": "at://did:plc:nobody/dev.knotless.issue/x"}),
        ),
        // Only its author changes what a pull says, and a pull is closed,
        // not deleted.
        (
            "pull_edit",
            json!({"repo": repo, "uri": pull, "title": "x"}),
        ),
        ("comment_delete", json!({"repo": repo, "uri": issue})),
        (
            "pull_dismiss_review",
            json!({"repo": repo, "uri": clash, "reviewer": format!("at://{}/dev.knotless.comment/x", owner.account.did), "reason": "r"}),
        ),
    ] {
        let (text, err) = o.call(tool, args.clone());
        assert!(err, "{tool} {args}: {text}");
    }
}

#[test]
fn agents_moderate() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let mut operator = logged_in();
    let (base, _appview, _proxy) = appview(&rt, &operator.account.did);
    let mut owner = logged_in();
    owner.set("KNOTLESS_APPVIEW", &base);
    // Delegating is approved in the browser.
    let browser = browser(&owner.account, "");
    owner.set("KNOTLESS_BROWSER", &browser);
    operator.set("KNOTLESS_APPVIEW", &base);
    let (o, c) = (Client::new(&owner), Client::new(&operator));
    let repo = c_repo(&o.json("repo_create", json!({"name": "moderated"})));
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "start", "changes": [{"path": "a", "content": "a\n"}]}));
    let issue = c.json("issue_create", json!({"repo": repo, "title": "Spam"}))["uri"]
        .as_str()
        .unwrap()
        .to_string();
    let items = || {
        o.json("issue_list", json!({"repo": repo}))
            .as_array()
            .unwrap()
            .len()
    };
    wait_until(|| items() == 1);

    let hidden = o.json("mod_hide", json!({"repo": repo, "uri": issue}));
    assert_eq!(hidden["hidden"], true);
    wait_until(|| items() == 0);
    o.json(
        "mod_hide",
        json!({"repo": repo, "uri": issue, "undo": true}),
    );
    wait_until(|| items() == 1);
    let them = operator.account.handle.clone();
    assert_eq!(
        o.json("mod_block", json!({"handle": them}))["blocked"],
        true
    );
    wait_until(|| items() == 0);
    o.json("mod_block", json!({"handle": them, "undo": true}));
    wait_until(|| items() == 1);
    o.json("mod_block", json!({"handle": them, "repo": repo}));
    wait_until(|| items() == 0);
    o.json(
        "mod_block",
        json!({"handle": them, "repo": repo, "undo": true}),
    );
    wait_until(|| items() == 1);

    let report = c.json(
        "mod_report",
        json!({"subject": repo, "reason": "spam", "text": "all of it"}),
    );
    assert_eq!(report["id"], 1);
    assert_eq!(
        report["subject"]["uri"],
        format!("at://{}/dev.knotless.repo/moderated", owner.account.did)
    );
    c.json(
        "mod_report",
        json!({"subject": owner.account.handle, "reason": "rude"}),
    );
    let reports = c.json("admin_reports", json!({}));
    assert_eq!(reports["reports"].as_array().unwrap().len(), 2);
    let stats = c.json("admin_stats", json!({"days": 1}));
    assert_eq!(stats["days"].as_array().unwrap().len(), 1, "{stats}");
    // Its operator reads its logs.
    let logs = c.json(
        "admin_logs",
        json!({"level": "warn", "min_ms": 1, "limit": 5}),
    );
    assert!(logs["lines"].is_array(), "{logs}");
    let down = c.json("admin_takedown", json!({"subject": issue}));
    assert_eq!(down["takedown"]["applied"], true);
    wait_until(|| items() == 0);
    let status = c.json("admin_status", json!({"subject": issue}));
    assert_eq!(status["takedown"]["applied"], true);
    c.json("admin_takedown", json!({"subject": issue, "undo": true}));
    wait_until(|| items() == 1);

    for (who, tool, args) in [
        (&c, "mod_hide", json!({"repo": repo, "uri": issue})),
        (&o, "mod_block", json!({"handle": "nobody.test"})),
        (
            &c,
            "mod_report",
            json!({"subject": repo, "reason": "boring"}),
        ),
        (&o, "admin_takedown", json!({"subject": issue})),
        (&o, "admin_status", json!({"subject": issue})),
        (&o, "admin_reports", json!({})),
        (&o, "admin_stats", json!({})),
        (&o, "admin_logs", json!({"trace": "t"})),
    ] {
        let (text, err) = who.call(tool, args.clone());
        assert!(err, "{tool} {args}: {text}");
    }
}

fn c_repo(v: &Value) -> String {
    v["repo"].as_str().unwrap().to_string()
}

#[test]
fn agents_star() {
    let owner = logged_in();
    let o = Client::new(&owner);
    let repo = c_repo(&o.json("repo_create", json!({"name": "shiny"})));
    let fan = logged_in();
    let f = Client::new(&fan);
    let starred = f.json("repo_star", json!({"repo": repo}));
    assert_eq!(starred["starred"], true);
    let uri = starred["uri"].as_str().unwrap().to_string();
    assert_eq!(
        f.json("repo_star", json!({"repo": repo}))["uri"],
        uri.as_str()
    );
    let mine = f.json("repo_stars", json!({}));
    assert_eq!(mine["stars"][0]["uri"], uri.as_str());
    let shown = format!("knotless://{}/shiny", owner.account.handle);
    assert_eq!(mine["stars"][0]["repo"], shown);
    let theirs = o.json("repo_stars", json!({"handle": fan.account.handle}));
    assert_eq!(theirs, mine);
    let unstarred = f.json("repo_star", json!({"repo": repo, "undo": true}));
    assert_eq!(unstarred, json!({"starred": false, "uri": null}));
    assert_eq!(f.json("repo_stars", json!({})), json!({"stars": []}));
}

/// An agent follows an account, sees whom it follows, and unfollows it;
/// who follows an account takes an appview.
#[test]
fn agents_follow() {
    let owner = logged_in();
    let fan = logged_in();
    let f = Client::new(&fan);
    let account = owner.account.handle.clone();
    let followed = f.json("account_follow", json!({"handle": account}));
    assert_eq!(followed["following"], true);
    let uri = followed["uri"].as_str().unwrap().to_string();
    assert_eq!(
        f.json("account_follow", json!({"handle": account}))["uri"],
        uri.as_str()
    );
    let mine = f.json("account_follows", json!({}));
    assert_eq!(mine["follows"][0]["uri"], uri.as_str());
    assert_eq!(mine["follows"][0]["handle"], account.as_str());
    let theirs = f.json("account_follows", json!({"handle": fan.account.handle}));
    assert_eq!(theirs, mine);
    let (why, err) = f.call("account_followers", json!({}));
    assert!(err && why.contains("KNOTLESS_APPVIEW"), "{why}");
    let unfollowed = f.json("account_follow", json!({"handle": account, "undo": true}));
    assert_eq!(unfollowed, json!({"following": false, "uri": null}));
    assert_eq!(f.json("account_follows", json!({})), json!({"follows": []}));
}

/// An owner hears, from the appview, of what others did that concerns it:
/// a star, a follow, an issue on its repository and a comment on its
/// issue; new until it lists them, over MCP or the command line.
#[test]
fn agents_hear_what_others_did() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let (base, _appview, _proxy) = appview(&rt, "");
    let mut owner = logged_in();
    owner.set("KNOTLESS_APPVIEW", &base);
    owner.set("KNOTLESS_DID_WEB_SCHEME", "http");
    let mut fan = logged_in();
    fan.set("KNOTLESS_APPVIEW", &base);
    fan.set("KNOTLESS_DID_WEB_SCHEME", "http");
    let (o, f) = (Client::new(&owner), Client::new(&fan));
    let repo = c_repo(&o.json("repo_create", json!({"name": "heard"})));
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "start", "changes": [{"path": "a", "content": "a\n"}]}));
    let mine = o.json("issue_create", json!({"repo": repo, "title": "Mine"}))["uri"]
        .as_str()
        .unwrap()
        .to_string();
    f.json("repo_star", json!({"repo": repo}));
    f.json("account_follow", json!({"handle": owner.account.handle}));
    f.json("issue_create", json!({"repo": repo, "title": "Theirs"}));
    f.json(
        "comment_add",
        json!({"repo": repo, "uri": mine, "body": "me too"}),
    );

    // Listed without being marked seen, until all four are there.
    let peek = || o.json("notification_list", json!({"peek": true}))["notifications"].clone();
    wait_until(|| peek().as_array().unwrap().len() == 4);
    let heard = peek();
    let mut reasons: Vec<&str> = heard
        .as_array()
        .unwrap()
        .iter()
        .map(|n| n["reason"].as_str().unwrap())
        .collect();
    reasons.sort();
    assert_eq!(reasons, ["comment", "follow", "issue", "star"]);
    // Who follows the owner, as the appview counts them.
    let followers = o.json("account_followers", json!({}));
    assert_eq!(
        followers["followers"][0]["handle"],
        fan.account.handle.as_str()
    );
    assert!(heard.as_array().unwrap().iter().all(|n| n["new"] == true));
    let comment = heard
        .as_array()
        .unwrap()
        .iter()
        .find(|n| n["reason"] == "comment");
    let comment = comment.unwrap();
    assert_eq!(comment["subject"], mine.as_str());
    assert_eq!(comment["author"], fan.account.handle.as_str());
    let about = format!("knotless://{}/heard \"Mine\"", owner.account.handle);
    assert_eq!(comment["about"], about);
    // Each names its repository, for pull_show, and what it is about: the
    // issue itself, the repository starred, and for a follow, nothing.
    let named = format!("{}/heard", owner.account.handle);
    let of = |reason: &str| {
        let mut all = heard.as_array().unwrap().iter();
        all.find(|n| n["reason"] == reason).unwrap().clone()
    };
    let issue = of("issue");
    assert_eq!(
        (&issue["subject"], &issue["repo"]),
        (&issue["uri"], &json!(named))
    );
    let starred = format!("at://{}/dev.knotless.repo/heard", owner.account.did);
    assert_eq!(of("star")["subject"], starred);
    assert_eq!(
        (&of("follow")["subject"], &of("follow")["repo"]),
        (&Value::Null, &Value::Null)
    );

    // Of one kind, on the command line and here, marking none seen.
    let (code, lines) = owner.cli(
        &["notification", "list", "--kind", "stars-and-follows"],
        b"",
    );
    assert_eq!((code, lines.lines().count()), (0, 2), "{lines}");
    let comments = o.json("notification_list", json!({"kind": "comments"}));
    assert_eq!(comments["notifications"][0]["reason"], "comment");
    assert_eq!(comments["notifications"].as_array().unwrap().len(), 1);
    assert_eq!(comments["markedSeen"], false);
    assert_eq!(owner.cli(&["notification", "list", "--kind"], b"").0, 1);

    // The command line peeks as well; listing marks them seen.
    let (code, lines) = owner.cli(&["notification", "list", "--peek"], b"");
    assert_eq!(code, 0, "{lines}");
    assert_eq!(lines.lines().filter(|l| l.starts_with("new\t")).count(), 4);
    assert_eq!(owner.cli(&["notification", "list", "--bogus"], b"").0, 1);
    assert_eq!(owner.cli(&["notification", "list"], b"").0, 0);
    let listed = o.json("notification_list", json!({}));
    assert_eq!(listed["markedSeen"], true);
    let listed = listed["notifications"].clone();
    assert!(listed.as_array().unwrap().iter().all(|n| n["new"] == false));
    let peeked = o.json("notification_list", json!({"peek": true}));
    assert_eq!(peeked["markedSeen"], false);
    // Having commented, the fan hears of what is said after in the thread.
    o.json(
        "comment_add",
        json!({"repo": repo, "uri": mine, "body": "thanks"}),
    );
    let theirs = || f.json("notification_list", json!({"peek": true}))["notifications"].clone();
    wait_until(|| theirs().as_array().unwrap().len() == 1);
    let reply = &theirs()[0];
    assert_eq!(
        (&reply["reason"], &reply["subject"]),
        (&json!("comment"), &json!(mine))
    );
    assert_eq!(reply["author"], owner.account.handle.as_str());
    // A review of the owner's pull that names them, on its lines too, is
    // heard of once: as a review, mentioning them, its line comments
    // counted.
    let side = json!([{"path": "b", "content": "b\n"}]);
    o.json(
        "repo_commit",
        json!({"repo": repo, "branch": "side", "message": "b", "changes": side}),
    );
    let opened = json!({"repo": repo, "base": "main", "head_repo": repo, "head_branch": "side", "title": "Add b"});
    let pull = o.json("pull_create", opened)["uri"]
        .as_str()
        .unwrap()
        .to_string();
    let body = format!("Not yet, @{}", owner.account.handle);
    let lines = json!([{"path": "b", "line": 1, "body": "Why b?"}, {"path": "b", "line": 1, "body": "And here"}]);
    let review = json!({"repo": repo, "uri": pull, "body": body, "changes": true, "lines": lines});
    f.json("comment_add", review);
    let on = |n: &&Value| n["subject"] == pull.as_str();
    wait_until(|| peek().as_array().unwrap().iter().any(|n| on(&n)));
    let heard = peek();
    let of_it: Vec<&Value> = heard.as_array().unwrap().iter().filter(on).collect();
    assert_eq!(of_it.len(), 1, "{heard}");
    let said = (
        &of_it[0]["reason"],
        &of_it[0]["verdict"],
        &of_it[0]["mentioned"],
    );
    assert_eq!(said, (&json!("comment"), &json!("changes"), &json!(true)));
    assert_eq!(of_it[0]["lineComments"], 2);
    // Without an appview there is no one to ask.
    let mut alone = logged_in();
    alone.set("KNOTLESS_APPVIEW", "");
    let (why, err) = Client::new(&alone).call("notification_list", json!({}));
    assert!(err && why.contains("KNOTLESS_APPVIEW"), "{why}");
    // Whether the appview is well, asked of it, or of one named.
    let status = o.json("status", json!({"repo": repo}));
    assert!(status["ok"].is_boolean(), "{status}");
    let named = o.json("status", json!({"server": base}));
    assert!(named["ok"].is_boolean(), "{named}");
    let (why, err) = Client::new(&alone).call("status", json!({}));
    assert!(err && why.contains("give a server"), "{why}");
}

/// An agent watches a repository it has no part in and hears of an
/// issue opened on it; subscribes to the issue and hears of its comments;
/// mutes it and hears nothing of it; and lists what it chose, over MCP or
/// the command line.
#[test]
fn agents_watch_subscribe_and_mute() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let (base, _appview, _proxy) = appview(&rt, "");
    let [mut owner, mut fan, mut watcher] = [logged_in(), logged_in(), logged_in()];
    for s in [&mut owner, &mut fan, &mut watcher] {
        s.set("KNOTLESS_APPVIEW", &base);
        s.set("KNOTLESS_DID_WEB_SCHEME", "http");
    }
    let (o, f, w) = (
        Client::new(&owner),
        Client::new(&fan),
        Client::new(&watcher),
    );
    let repo = c_repo(&o.json("repo_create", json!({"name": "watched"})));
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "start", "changes": [{"path": "a", "content": "a\n"}]}));
    let record = format!("at://{}/dev.knotless.repo/watched", owner.account.did);
    let watching = w.json("notification_watch", json!({"repo": repo}));
    assert_eq!(
        (&watching["subject"], &watching["level"]),
        (&json!(record), &json!("all"))
    );
    let issue = f.json("issue_create", json!({"repo": repo, "title": "Theirs"}))["uri"]
        .as_str()
        .unwrap()
        .to_string();
    let peek = || w.json("notification_list", json!({"peek": true}))["notifications"].clone();
    let heard = |reason: &str| {
        let all = peek();
        let all = all.as_array().unwrap().iter();
        all.filter(|n| n["reason"] == reason).count()
    };
    wait_until(|| heard("watching") == 1);
    assert_eq!(peek()[0]["subject"], issue.as_str());

    // Subscribed, its comments are heard of as such, not as watching.
    let subscribed = w.json("notification_subscribe", json!({"uri": issue}));
    assert_eq!(subscribed["level"], "subscribed");
    f.json(
        "comment_add",
        json!({"repo": repo, "uri": issue, "body": "more"}),
    );
    wait_until(|| heard("subscribed") == 1);
    assert_eq!(heard("watching"), 1);

    // Muted on the command line, nothing of it is heard.
    let (code, said) = watcher.cli(&["notification", "mute", &issue], b"");
    assert_eq!((code, said.trim()), (0, format!("muted\t{issue}").as_str()));
    assert!(peek().as_array().unwrap().is_empty());
    let url = format!("knotless://{}/watched", owner.account.handle);
    let (code, said) = watcher.cli(&["notification", "watch", &url, "releases"], b"");
    assert_eq!(
        (code, said.trim()),
        (0, format!("releases\t{record}").as_str())
    );
    let (code, listed) = watcher.cli(&["notification", "subscriptions"], b"");
    assert_eq!((code, listed.lines().count()), (0, 2), "{listed}");
    assert!(listed.starts_with("releases\t"), "{listed}");
    let all = w.json("notification_subscriptions", json!({}));
    assert_eq!(all["subscriptions"][1]["subject"], issue.as_str());
    assert!(all["subscriptions"][1]["createdAt"].is_string());
    // Each forgotten: the issue heard of again as watching does.
    let (code, said) = watcher.cli(&["notification", "unsubscribe", &issue], b"");
    assert_eq!(
        (code, said.trim()),
        (0, format!("participating\t{issue}").as_str())
    );
    let (code, said) = watcher.cli(&["notification", "subscribe", &issue], b"");
    assert_eq!((code, said.split('\t').next()), (0, Some("subscribed")));
    let (code, _) = watcher.cli(&["notification", "watch", &url], b"");
    assert_eq!(code, 0);
    let forgot = w.json(
        "notification_watch",
        json!({"repo": repo, "level": "participating"}),
    );
    assert_eq!(forgot.get("createdAt"), None);
    let muted = w.json("notification_mute", json!({"uri": issue}));
    assert_eq!(muted["level"], "muted");
    // Refused for what is no repository, pull or issue, or a level wrong
    // for it.
    let (why, err) = w.call("notification_mute", json!({"uri": record}));
    assert!(err && why.contains("no level"), "{why}");
    let undone = w.json("notification_unsubscribe", json!({"uri": issue}));
    assert_eq!(undone["level"], "participating");
    let (code, _) = watcher.cli(&["notification", "mute"], b"");
    assert_eq!(code, 1);
}

/// What only the command line did before, as tools: an owner's
/// house-keeping, from making a repository to deleting it.
#[test]
fn agents_keep_house() {
    let s = logged_in();
    let c = Client::new(&s);
    let made = c.json("repo_create", json!({"name": "kept", "runners": []}));
    assert_eq!(made["runners"], json!([]));
    let repo = c_repo(&made);
    for (n, path) in ["a", "b"].iter().enumerate() {
        let change = json!([{"path": path, "content": format!("{n}\n")}]);
        c.json(
            "repo_commit",
            json!({"repo": repo, "branch": "trunk", "message": path, "changes": change}),
        );
    }
    assert_eq!(c.json("branch_rules", json!({"repo": repo})), json!([]));
    c.json("branch_protect", json!({"repo": repo, "branch": "trunk"}));
    let rules = c.json("branch_rules", json!({"repo": repo}));
    assert_eq!(rules[0]["branch"], "trunk");

    // With no grace period here, both packs fold into one.
    let compacted = c.json("repo_compact", json!({"repo": repo}));
    let counted = (&compacted["before"], &compacted["removed"]);
    assert_eq!(counted, (&json!(2), &json!(2)), "{compacted}");
    assert_eq!(c.json("repo_storage", json!({"repo": repo}))["packs"], 1);

    // Asking for code owners where the owner alone owns a path warns
    // that their own pull of it merges only by force.
    let handle = s.account.handle.clone();
    let owners = json!([{"path": "CODEOWNERS", "content": format!("*  @{handle}\n")}]);
    c.json(
        "repo_commit",
        json!({"repo": repo, "branch": "trunk", "message": "owners", "changes": owners}),
    );
    let asks = json!({"repo": repo, "branch": "trunk", "reviews": 1, "code_owners": true});
    let rules = c.json("branch_protect", asks);
    let warned = rules[0]["warnings"][0].as_str().unwrap();
    assert!(
        warned.starts_with(&format!("@{handle} alone owns *, ")),
        "{rules}"
    );
    assert_eq!(c.json("branch_rules", json!({"repo": repo})), rules);

    let (why, err) = c.call("repo_delete", json!({"repo": repo, "confirm": "nope"}));
    assert!(err && why.contains("kept"), "{why}");
    let deleted = c.json("repo_delete", json!({"repo": repo, "confirm": "kept"}));
    let shown = format!("knotless://{}/kept", s.account.handle);
    assert_eq!(deleted["deleted"], shown);
    let (why, err) = c.call("repo_refs", json!({"repo": repo}));
    assert!(err, "{why}");
}

/// What takes an appview, over the tools and the command line alike:
/// finding an account by its handle, a pull's diff, renaming the branch it
/// targets, and how a triager labels.
#[test]
fn agents_and_the_command_line_find_and_rename() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let (base, _appview, _proxy) = appview(&rt, "");
    let mut owner = logged_in();
    owner.set("KNOTLESS_APPVIEW", &base);
    owner.set("KNOTLESS_DID_WEB_SCHEME", "http");
    let o = Client::new(&owner);
    let repo = c_repo(&o.json("repo_create", json!({"name": "found"})));
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "start", "changes": [{"path": "a", "content": "a\n"}]}));
    o.json("repo_commit", json!({"repo": repo, "branch": "topic", "message": "b", "changes": [{"path": "b", "content": "b\n"}]}));
    o.json("branch_create", json!({"repo": repo, "name": "side"}));

    let handle = owner.account.handle.clone();
    let find = || o.json("account_search", json!({"text": handle, "limit": 50}))["owners"].clone();
    let mine = |v: &Value| v["owner"]["handle"] == handle.as_str();
    wait_until(|| find().as_array().unwrap().iter().any(mine));
    let found = find();
    let me = found.as_array().unwrap().iter().find(|v| mine(v));
    assert_eq!(me.unwrap()["repoCount"], 1);
    let (code, out) = owner.cli(&["account", "search", &handle, "--limit", "50"], b"");
    assert_eq!(code, 0, "{out}");
    assert!(out.lines().any(|l| l == format!("{handle}\t1")), "{out}");
    assert_eq!(
        owner.cli(&["account", "search", &handle, "--bogus"], b"").0,
        1
    );
    assert_eq!(owner.cli(&["account", "search", &handle], b"").0, 0);
    let mut alone = logged_in();
    alone.set("KNOTLESS_APPVIEW", "");
    let (why, err) = Client::new(&alone).call("account_search", json!({"text": handle}));
    assert!(err && why.contains("KNOTLESS_APPVIEW"), "{why}");

    let url = format!("knotless://{repo}");
    let (code, pull) = owner.cli(
        &["pull", "create", &url, "side", &url, "topic", "Topic"],
        b"",
    );
    assert_eq!(code, 0, "{pull}");
    let pulls = || o.json("pull_list", json!({"repo": repo}));
    wait_until(|| pulls().as_array().unwrap().len() == 1);
    let (code, diff) = owner.cli(&["pull", "diff", &url, &pull], b"");
    assert!(code == 0 && diff.contains("+b"), "{diff}");
    let (code, out) = owner.cli(&["branch", "rename", &url, "side", "next"], b"");
    assert_eq!(code, 0, "{out}");
    assert_eq!(out, format!("renamed side to next\nretargeted {pull}"));
    let (code, sha) = owner.cli(&["tag", "create", &url, "v1", "next"], b"");
    assert!(code == 0 && sha.len() == 40, "{sha}");
    let (code, out) = owner.cli(&["tag", "delete", &url, "v1"], b"");
    assert_eq!((code, out.as_str()), (0, "deleted v1"));

    let scores = o.json("triager_eval", json!({"repo": repo, "handle": handle}));
    assert!(scores.is_array(), "{scores}");
}

/// An agent claims the addresses its commits show as its by, and lists
/// whom it blocks, as the command line does.
#[test]
fn agents_keep_their_settings() {
    let s = logged_in();
    let them = logged_in();
    let c = Client::new(&s);
    assert_eq!(c.json("account_email", json!({})), json!({"claimed": 0}));
    let add = json!({"address": "Agent@Example.com"});
    let added = c.json("account_email_add", add.clone());
    assert_eq!(added, json!({"changed": true, "claimed": 1}));
    assert_eq!(c.json("account_email_add", add)["changed"], false);
    let (code, out) = s.cli(&["account", "email"], b"");
    assert_eq!((code, out.as_str()), (0, "1 address claimed"));
    let gone = c.json(
        "account_email_remove",
        json!({"address": "agent@example.com"}),
    );
    assert_eq!(gone, json!({"changed": true, "claimed": 0}));
    let (why, err) = c.call("account_email_add", json!({"address": "nowhere"}));
    assert!(err && why.contains("no email address"), "{why}");

    assert_eq!(c.json("mod_blocks", json!({})), json!({"blocks": []}));
    let handle = them.account.handle.clone();
    c.json("mod_block", json!({"handle": handle}));
    let repo = c_repo(&c.json("repo_create", json!({"name": "kept"})));
    c.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "start", "changes": [{"path": "a", "content": "a\n"}]}));
    c.json("mod_block", json!({"handle": handle, "repo": repo}));
    let listed = c.json("mod_blocks", json!({}));
    let blocks = listed["blocks"].as_array().unwrap();
    assert_eq!(blocks.len(), 2, "{listed}");
    assert!(blocks.iter().all(|b| b["did"] == them.account.did.as_str()));
    assert!(blocks.iter().all(|b| b["handle"] == handle.as_str()));
    let named = format!("at://{}/dev.knotless.repo/kept", s.account.did);
    assert_eq!(blocks.iter().filter(|b| b["repo"] == named).count(), 1);
    assert_eq!(blocks.iter().filter(|b| b["repo"].is_null()).count(), 1);
    // Anyone's, by handle, as their repo has them.
    let mine = json!({"handle": s.account.handle});
    assert_eq!(Client::new(&them).json("mod_blocks", mine), listed);
    let (code, out) = s.cli(&["mod", "blocks"], b"");
    assert_eq!((code, out.lines().count()), (0, 2), "{out}");
}

/// What an account hears of is its to choose, kept by the appview: a
/// reason turned off, or anyone it does not follow, is not heard of, over
/// MCP and the command line alike.
#[test]
fn agents_choose_what_they_hear() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let (base, _appview, _proxy) = appview(&rt, "");
    let mut owner = logged_in();
    owner.set("KNOTLESS_APPVIEW", &base);
    owner.set("KNOTLESS_DID_WEB_SCHEME", "http");
    let mut fan = logged_in();
    fan.set("KNOTLESS_APPVIEW", &base);
    fan.set("KNOTLESS_DID_WEB_SCHEME", "http");
    let (o, f) = (Client::new(&owner), Client::new(&fan));
    let all = o.json("notification_settings", json!({}));
    assert_eq!(all["followed_only"], false);
    let listed = all["reasons"].as_array().unwrap();
    let reasons: Vec<&str> = listed
        .iter()
        .map(|r| r["reason"].as_str().unwrap())
        .collect();
    assert_eq!(reasons[..5], ["star", "follow", "pull", "issue", "comment"]);
    assert!(listed.iter().all(|r| r["enabled"] == true));
    let off = o.json("notification_settings", json!({"off": ["star"]}));
    assert_eq!(
        off["reasons"][0],
        json!({"reason": "star", "enabled": false})
    );
    assert_eq!(off["reasons"][1]["enabled"], true);
    let both = json!({"followed_only": true, "anyone": true});
    let (why, err) = o.call("notification_settings", both);
    assert!(err && why.contains("not both"), "{why}");
    let only = o.json("notification_settings", json!({"followed_only": true}));
    assert_eq!(only["followed_only"], true);
    let anyone = o.json("notification_settings", json!({"anyone": true}));
    assert_eq!(anyone["followed_only"], false);
    let (why, err) = o.call("notification_settings", json!({"off": ["stars"]}));
    assert!(err && why.contains("is no reason"), "{why}");

    // A star, unheard of; the follow after it, heard.
    let repo = c_repo(&o.json("repo_create", json!({"name": "quiet"})));
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "start", "changes": [{"path": "a", "content": "a\n"}]}));
    f.json("repo_star", json!({"repo": repo}));
    f.json("account_follow", json!({"handle": owner.account.handle}));
    let peek = || o.json("notification_list", json!({"peek": true}))["notifications"].clone();
    wait_until(|| !peek().as_array().unwrap().is_empty());
    let heard = peek();
    assert_eq!(heard.as_array().unwrap().len(), 1, "{heard}");
    assert_eq!(heard[0]["reason"], "follow");

    // The command line, the same: only from accounts followed, which the
    // fan is not, then from anyone, with stars again.
    let settings = |args: &[&str]| owner.cli(&[&["notification", "settings"], args].concat(), b"");
    let (code, out) = settings(&["--followed-only", "--off", "issue"]);
    assert_eq!(code, 0, "{out}");
    assert!(out.contains("issue\toff"), "{out}");
    assert!(out.ends_with("from\taccounts you follow"), "{out}");
    assert!(peek().as_array().unwrap().is_empty());
    let (code, out) = settings(&["--anyone", "--on", "star"]);
    assert_eq!(code, 0, "{out}");
    assert!(out.starts_with("star\ton\nfollow\ton\n"), "{out}");
    assert!(out.ends_with("from\tanyone"), "{out}");
    assert_eq!(peek().as_array().unwrap().len(), 2);
    assert_eq!(settings(&[]).1, out);
    assert_eq!(settings(&["--bogus"]).0, 1);
    // Each account's are its own.
    let theirs = f.json("notification_settings", json!({}));
    assert_eq!(theirs["reasons"], all["reasons"]);
}

/// An agent makes a theme for the pages: a palette checked for contrast
/// as the pages check their own, published for anyone to choose, chosen,
/// found, and deleted; the command line does the same.
#[test]
fn agents_make_themes() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let (base, _appview, _proxy) = appview(&rt, "");
    let mut maker = logged_in();
    maker.set("KNOTLESS_APPVIEW", &base);
    maker.set("KNOTLESS_DID_WEB_SCHEME", "http");
    let mut other = logged_in();
    other.set("KNOTLESS_APPVIEW", &base);
    other.set("KNOTLESS_DID_WEB_SCHEME", "http");
    let (m, o) = (Client::new(&maker), Client::new(&other));
    let paper = json!({"colorScheme": "light", "background": "#ffffff", "text": "#1f2328",
        "primary": "#1f6feb", "accent": "#0969da"});
    let mut pale = paper.clone();
    pale["textMuted"] = json!("#eeeeee");
    let mine = json!({"handle": maker.account.handle});
    assert_eq!(m.json("theme_list", mine.clone()), json!({"themes": []}));

    // Checked alone: what falls short, named as the palette names it.
    let fine = m.json("theme_check", json!({"palette": paper}));
    assert_eq!(fine, json!({"readable": true, "shortfalls": []}));
    let short = m.json("theme_check", json!({"palette": pale}));
    assert_eq!(short["readable"], false);
    assert_eq!(short["shortfalls"][0]["text"], "textMuted");
    assert_eq!(short["shortfalls"][0]["on"], "background");
    let refused = |c: &Client, tool: &str, args: Value, why: &str| {
        let (said, err) = c.call(tool, args);
        assert!(err && said.contains(why), "{said}");
    };
    refused(
        &m,
        "theme_check",
        json!({"palette": {"colorScheme": "dark"}}),
        "background",
    );
    refused(&m, "theme_use", json!({"theme": "palette"}), "none is");
    refused(&m, "theme_use", json!({"theme": "sepia"}), "is no theme");
    let hard = json!({"name": "Pale", "palette": pale});
    refused(&m, "theme_publish", hard, "hard to read");
    let blank = json!({"name": " ", "palette": paper});
    refused(&m, "theme_publish", blank, "a theme's name");
    assert!(maker.records("dev.knotless.theme").is_empty());

    // Published and used at once; found by anyone, as the appview lists it.
    let made = m.json(
        "theme_publish",
        json!({"name": "Quokka paper", "palette": paper, "use": true}),
    );
    assert_eq!(made["using"], "Quokka paper");
    let uri = made["uri"].as_str().unwrap().to_string();
    assert!(
        uri.starts_with(&format!("at://{}/dev.knotless.theme/", maker.account.did)),
        "{uri}"
    );
    let found = || o.json("theme_list", json!({"find": "quokka"}))["themes"].clone();
    wait_until(|| !found().as_array().unwrap().is_empty());
    assert_eq!(found()[0]["uri"], uri.as_str());
    assert_eq!(found()[0]["creator"], maker.account.handle.as_str());
    assert_eq!(found()[0]["palette"], paper);
    let theirs = o.json("theme_list", mine);
    assert_eq!(theirs["themes"][0]["name"], "Quokka paper");
    // Chosen by another, as published; or one of the pages', or the system's.
    for (choice, drawn) in [
        (uri.as_str(), "Quokka paper"),
        ("mocha", "mocha"),
        ("system", "the system's light or dark"),
    ] {
        assert_eq!(
            o.json("theme_use", json!({"theme": choice})),
            json!({"using": drawn})
        );
    }
    let own = o.json("theme_use", json!({"theme": "palette", "palette": paper}));
    assert_eq!(own, json!({"using": "your own"}));
    let gone = format!(
        "at://{}/dev.knotless.theme/3zzzzzzzzzzzz",
        maker.account.did
    );
    refused(&o, "theme_use", json!({"theme": gone}), "no such theme");
    refused(
        &o,
        "theme_use",
        json!({"theme": "at://nowhere"}),
        "is no theme",
    );
    // A record no palette is, as any client could write.
    maker.put_record("dev.knotless.theme", "3broken", json!({"$type": "dev.knotless.theme", "name": "Broken", "palette": {"colorScheme": "sepia"}, "createdAt": "2026-01-01T00:00:00Z"}));
    let broken = format!("at://{}/dev.knotless.theme/3broken", maker.account.did);
    refused(&o, "theme_use", json!({"theme": broken}), "is no palette");
    // Only its maker deletes it.
    refused(&o, "theme_delete", json!({"uri": uri}), "no theme of yours");
    assert_eq!(
        m.json("theme_delete", json!({"uri": uri})),
        json!({"deleted": uri})
    );
    assert_eq!(maker.records("dev.knotless.theme").len(), 1);
    let plain = m.json(
        "theme_publish",
        json!({"name": "Plain paper", "palette": paper}),
    );
    assert!(plain.get("using").is_none(), "{plain}");
    let plain = plain["uri"].as_str().unwrap().to_string();
    m.json("theme_delete", json!({"uri": plain}));

    // The command line, the same.
    let file = maker.path("night.json");
    let night = json!({"colorScheme": "dark", "background": "#0d1117", "text": "#e6edf3",
        "primary": "#2f81f7", "accent": "#58a6ff"});
    std::fs::write(&file, night.to_string()).unwrap();
    let file = file.to_str().unwrap();
    let cli = |args: &[&str], stdin: &[u8]| maker.cli(args, stdin);
    assert_eq!(
        cli(&["theme", "check", file], b""),
        (0, "every text reads at 4.5 to 1 or more".into())
    );
    let record = json!({"name": "Pale", "palette": pale}).to_string();
    // Refused as an error, on stderr, as the binary says it.
    let (ok, _, why) = maker.knotless(&["theme", "check", "-"], record.as_bytes());
    assert!(!ok && why.contains("textMuted on background"), "{why}");
    let (code, uri) = cli(
        &["theme", "publish", "Wombat night", "-", "--use"],
        night.to_string().as_bytes(),
    );
    assert_eq!(code, 0, "{uri}");
    assert!(uri.contains("/dev.knotless.theme/"), "{uri}");
    // Published alone, not used; and not with what it does not know.
    let (code, alone) = cli(
        &["theme", "publish", "Wombat dusk", "-"],
        night.to_string().as_bytes(),
    );
    assert_eq!(code, 0, "{alone}");
    assert_eq!(
        cli(&["theme", "delete", &alone], b""),
        (0, "deleted".into())
    );
    let bogus = cli(
        &["theme", "publish", "Wombat", "-", "--bogus"],
        night.to_string().as_bytes(),
    );
    assert_eq!(bogus.0, 1);
    assert_eq!(
        cli(&["theme", "use", "dracula"], b""),
        (0, "drawn in dracula".into())
    );
    assert_eq!(
        cli(&["theme", "use", file], b""),
        (0, "drawn in your own".into())
    );
    assert_eq!(
        cli(&["theme", "use", "-"], night.to_string().as_bytes()),
        (0, "drawn in your own".into())
    );
    let named = || cli(&["theme", "list", "--find", "wombat"], b"");
    wait_until(|| named().1.starts_with("Wombat night\t"));
    assert_eq!(
        named().1,
        format!("Wombat night\t{}\t{uri}", maker.account.handle)
    );
    let (code, all) = cli(&["theme", "list"], b"");
    assert!(code == 0 && all.contains(&uri), "{all}");
    let (code, mine) = cli(&["theme", "list", &maker.account.handle], b"");
    assert!(code == 0 && mine.contains(&uri), "{mine}");
    assert_eq!(cli(&["theme", "delete", &uri], b""), (0, "deleted".into()));
    let wrong: [&[&str]; 8] = [
        &["themes", "--bogus"],
        &["themes", "a.test", "b.test"],
        &["theme", "frob"],
        &["theme", "publish", "Night", file, "--bogus"],
        &["theme", "check", "/nowhere.json"],
        &["theme", "check", "-"],
        &["theme", "use", "sepia"],
        &["theme"],
    ];
    for args in wrong {
        assert_eq!(cli(args, b"not json").0, 1, "{args:?}");
    }
}

/// An agent reacts to an issue and a comment, sees the counts the appview
/// keeps in issue_show, and takes a reaction back; the command line does
/// the same.
#[test]
fn agents_react() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let (base, _appview, _proxy) = appview(&rt, "");
    let mut owner = logged_in();
    owner.set("KNOTLESS_APPVIEW", &base);
    let mut fan = logged_in();
    fan.set("KNOTLESS_APPVIEW", &base);
    let (o, f) = (Client::new(&owner), Client::new(&fan));
    let repo = c_repo(&o.json("repo_create", json!({"name": "reacted"})));
    o.json("repo_commit", json!({"repo": repo, "branch": "main", "message": "start", "changes": [{"path": "a", "content": "a\n"}]}));
    let issue = o.json("issue_create", json!({"repo": repo, "title": "Shiny"}))["uri"]
        .as_str()
        .unwrap()
        .to_string();
    let said = o.json(
        "comment_add",
        json!({"repo": repo, "uri": issue, "body": "look"}),
    )["uri"]
        .as_str()
        .unwrap()
        .to_string();

    let rocket = json!({"repo": repo, "uri": issue, "content": "rocket"});
    let reacted = f.json("issue_react", rocket.clone());
    assert_eq!(reacted["reacted"], true);
    let uri = reacted["uri"].as_str().unwrap().to_string();
    assert!(uri.starts_with(&format!("at://{}/dev.knotless.reaction/", fan.account.did)));
    assert_eq!(f.json("issue_react", rocket)["uri"], uri.as_str());
    assert_eq!(fan.records("dev.knotless.reaction").len(), 1);
    let hooray = json!({"repo": repo, "uri": said, "content": "hooray"});
    let on_comment = f.json("comment_react", hooray);
    assert_eq!(on_comment["reacted"], true);
    // The command line reacts too.
    let url = format!("knotless://{repo}");
    let (code, out) = fan.cli(&["comment", "react", &url, &said, "hooray"], b"");
    assert_eq!(code, 0, "{out}");
    assert!(out.starts_with("at://"), "{out}");
    let (code, out) = owner.cli(&["comment", "react", &url, &said, "hooray"], b"");
    assert_eq!(code, 0, "{out}");

    // Both show what the appview counts, once it has them.
    wait_until(|| {
        let shown = o.json("issue_show", json!({"repo": repo, "uri": issue}));
        shown["reactions"] == json!({"rocket": 1})
            && shown["comments"][0]["reactions"] == json!({"hooray": 2})
    });
    let (code, shown) = owner.cli(&["pull", "show", &url, &issue], b"");
    assert_eq!(code, 0, "{shown}");
    assert!(shown.contains("reactions: rocket 1"), "{shown}");
    assert!(shown.contains("reactions: hooray 2"), "{shown}");

    // Taken back, over MCP and on the command line.
    let undo = json!({"repo": repo, "uri": issue, "content": "rocket", "undo": true});
    assert_eq!(
        f.json("issue_react", undo),
        json!({"reacted": false, "uri": null})
    );
    let undo = [
        "comment",
        "react",
        url.as_str(),
        said.as_str(),
        "hooray",
        "--undo",
    ];
    assert_eq!(fan.cli(&undo, b""), (0, "taken back".to_string()));
    assert!(fan.records("dev.knotless.reaction").is_empty());
    wait_until(|| {
        let shown = o.json("issue_show", json!({"repo": repo, "uri": issue}));
        shown["reactions"].is_null() && shown["comments"][0]["reactions"] == json!({"hooray": 1})
    });

    // One of the eight, to a pull, an issue or a comment on the repository.
    let tada = json!({"repo": repo, "uri": issue, "content": "tada"});
    let (why, err) = f.call("issue_react", tada);
    assert!(err && why.contains("+1 -1 laugh"), "{why}");
    let record = format!("at://{}/dev.knotless.repo/reacted", owner.account.did);
    let (why, err) = f.call(
        "pull_react",
        json!({"repo": repo, "uri": record, "content": "heart"}),
    );
    assert!(
        err && why.contains("is not a pull, an issue or a comment"),
        "{why}"
    );
    let missing = format!("at://{}/dev.knotless.issue/3zzzzzzzzzzzz", fan.account.did);
    let (why, err) = f.call(
        "comment_react",
        json!({"repo": repo, "uri": missing, "content": "heart"}),
    );
    assert!(err && why.contains("no pull, issue or comment"), "{why}");
    let bogus = [
        "comment",
        "react",
        url.as_str(),
        said.as_str(),
        "heart",
        "--bogus",
    ];
    assert_eq!(fan.cli(&bogus, b"").0, 1);
    if net().spaces {
        // On a private repository, a reaction is in its space, with what
        // it is about, and counted from there: none in the account's own.
        o.json("repo_create", json!({"name": "hush", "private": true}));
        let hush = format!("{}/hush", owner.account.handle);
        let quiet = o.json("issue_create", json!({"repo": hush, "title": "Quiet"}))["uri"]
            .as_str()
            .unwrap()
            .to_string();
        let public = owner.records("dev.knotless.reaction").len();
        let heart = json!({"repo": hush, "uri": quiet, "content": "heart"});
        let reacted = o.json("issue_react", heart.clone());
        assert_eq!(reacted["reacted"], true);
        assert_eq!(o.json("issue_react", heart)["uri"], reacted["uri"]);
        assert_eq!(owner.records("dev.knotless.reaction").len(), public);
        let shown = o.json("pull_show", json!({"repo": hush, "uri": quiet}));
        assert_eq!(shown["reactions"], json!({"heart": 1}));
        let hushed = format!("knotless://{hush}");
        let undo = [
            "issue",
            "react",
            hushed.as_str(),
            quiet.as_str(),
            "heart",
            "--undo",
        ];
        assert_eq!(owner.cli(&undo, b""), (0, "taken back".to_string()));
        let shown = o.json("pull_show", json!({"repo": hush, "uri": quiet}));
        assert!(shown["reactions"].is_null(), "{shown}");
    }
}

#[test]
fn agents_publish_releases() {
    let s = logged_in();
    let c = Client::new(&s);
    let repo = format!("{}/shipped", s.account.handle);
    c.ok(
        "repo_commit",
        json!({"repo": repo, "branch": "main", "message": "start", "changes": [{"path": "a", "content": "a"}]}),
    );
    let big = vec![b'x'; (1 << 20) + 1];
    use base64::Engine;
    let b64 = |b: &[u8]| base64::engine::general_purpose::STANDARD.encode(b);
    let published = c.json(
        "release_publish",
        json!({"repo": repo, "package": "tool", "version": "1.0.0", "notes": "First.", "commit": "c".repeat(40), "files": [
            {"name": "README", "content": "read me\n"},
            {"name": "tool.bin", "base64": b64(&[0, 1, 2, 255])},
            {"name": "big.txt", "base64": b64(&big)},
        ]}),
    );
    assert!(
        published["uri"]
            .as_str()
            .unwrap()
            .contains("/dev.knotless.release/")
    );
    c.ok(
        "release_publish",
        json!({"repo": repo, "package": "tool", "version": "1.1.0-rc.1", "files": [{"name": "README", "content": "next\n"}]}),
    );
    c.ok(
        "release_publish",
        json!({"repo": repo, "package": "other", "version": "0.1.0", "files": [{"name": "x", "content": "x"}]}),
    );
    for (files, says) in [
        (
            json!([{"name": "a", "content": "x", "base64": "eA=="}]),
            "exactly one",
        ),
        (json!([{"name": "a"}]), "exactly one"),
        (json!([{"name": "a", "base64": "!!"}]), "Invalid"),
    ] {
        let (text, err) = c.call(
            "release_publish",
            json!({"repo": repo, "package": "tool", "version": "2.0.0", "files": files}),
        );
        assert!(err && text.contains(says), "{text}");
    }
    let (text, err) = c.call(
        "release_publish",
        json!({"repo": repo, "package": "tool", "version": "1.0.0", "files": [{"name": "a", "content": "x"}]}),
    );
    assert!(err && text.contains("published already"), "{text}");

    // A yanked version is marked and is not the latest, until undone.
    let tool = json!({"repo": repo, "package": "tool", "version": "1.0.0"});
    let uri = c.json("release_yank", tool.clone())["uri"].clone();
    assert!(uri.as_str().unwrap().contains("/dev.knotless.release/"));
    let yanked = c.json("release_list", json!({"repo": repo, "package": "tool"}));
    let stable = yanked
        .as_array()
        .unwrap()
        .iter()
        .find(|r| r["version"] == "1.0.0")
        .unwrap();
    assert_eq!(
        (&stable["yanked"], &stable["latest"]),
        (&json!(true), &json!(false))
    );
    let mut undone = tool;
    undone["undo"] = json!(true);
    assert_eq!(c.json("release_yank", undone)["uri"], uri);

    // By package, highest first; the pre-release is never the latest.
    let all = c.json("release_list", json!({"repo": repo}));
    let listed: Vec<(&str, &str, bool)> = all
        .as_array()
        .unwrap()
        .iter()
        .map(|r| {
            let (p, v) = (
                r["package"].as_str().unwrap(),
                r["version"].as_str().unwrap(),
            );
            (p, v, r["latest"].as_bool().unwrap())
        })
        .collect();
    assert_eq!(
        listed,
        [
            ("other", "0.1.0", true),
            ("tool", "1.1.0-rc.1", false),
            ("tool", "1.0.0", true)
        ]
    );
    let tool = c.json("release_list", json!({"repo": repo, "package": "tool"}));
    assert_eq!(tool.as_array().unwrap().len(), 2);
    let first = &tool[1];
    assert_eq!(
        (first["notes"].as_str(), first["commit"].as_str()),
        (Some("First."), Some("c".repeat(40).as_str()))
    );
    assert_eq!(
        first["files"][1],
        json!({"name": "tool.bin", "size": 4, "sha256": knotless::release::sha256(&[0, 1, 2, 255])})
    );

    // A file of the latest, or of a version named, as text or base64.
    let read = |args: Value| c.json("release_read", args);
    let latest = read(json!({"repo": repo, "package": "tool", "file": "README"}));
    assert_eq!(latest, json!({"version": "1.0.0", "content": "read me\n"}));
    let rc =
        read(json!({"repo": repo, "package": "tool", "version": "1.1.0-rc.1", "file": "README"}));
    assert_eq!(rc["content"], "next\n");
    let bin = read(json!({"repo": repo, "package": "tool", "file": "tool.bin"}));
    assert_eq!(bin["base64"], b64(&[0, 1, 2, 255]));
    for (args, says) in [
        (
            json!({"package": "tool", "version": "9.9.9", "file": "README"}),
            "has published no tool 9.9.9",
        ),
        (
            json!({"package": "none", "file": "README"}),
            "has published no none latest",
        ),
        (
            json!({"package": "tool", "file": "missing"}),
            "has no file missing",
        ),
        (
            json!({"package": "tool", "file": "big.txt"}),
            "knotless release download",
        ),
    ] {
        let mut args = args;
        args["repo"] = json!(repo);
        let (text, err) = c.call("release_read", args);
        assert!(err && text.contains(says), "{text}");
    }
}

/// An account that invited no one is no organization; inviting takes a
/// gateway to act through, as the command line's does, and leaving takes
/// back the join record whatever the gateway does.
#[test]
fn organizations_over_mcp() {
    // Who is in an organization is read from the appview.
    let rt = tokio::runtime::Runtime::new().unwrap();
    let (base, _appview, _proxy) = appview(&rt, "");
    let mut s = logged_in();
    s.set("KNOTLESS_APPVIEW", &base);
    let other = account();
    let c = Client::new(&s);
    let me = s.account.handle.clone();
    let none = |did: &str, name: &str, inside: bool, changed: Value| json!({"org": did, "name": name, "organization": false, "inside": inside, "entries": [], "changed": changed});
    let mine = |changed| none(&s.account.did, &me, true, changed);
    assert_eq!(c.json("org_members", json!({})), mine(Value::Null));
    let removed = json!({"org": me, "who": other.handle, "organization": false});
    assert_eq!(
        c.json("org_remove", json!({"handle": other.handle})),
        mine(removed)
    );
    let deleted = json!({"removed": []});
    assert_eq!(c.json("org_delete", json!({})), mine(deleted.clone()));
    assert_eq!(c.json("org_delete", json!({"yes": true})), mine(deleted));
    let theirs = none(&other.did, &other.handle, false, Value::Null);
    assert_eq!(c.json("org_members", json!({"org": other.handle})), theirs);
    let public = c.json("org_members", json!({"org": other.handle, "public": true}));
    assert_eq!(public, theirs);
    let (text, err) = c.call("org_add", json!({"handle": other.handle, "admin": true}));
    assert!(
        err && text.ends_with("delegates its writes with the account_delegate tool"),
        "{text}"
    );
    let (text, err) = c.call("org_join", json!({"org": other.handle}));
    assert!(
        err && text.contains("exactly one of public or hidden"),
        "{text}"
    );
    let (text, err) = c.call("org_join", json!({"org": other.handle, "public": true}));
    assert!(err && text.contains("is not an organization"), "{text}");
    let (text, err) = c.call("org_join", json!({"org": other.handle, "hidden": true}));
    assert!(err, "{text}");
    let (text, err) = c.call("org_leave", json!({"org": other.handle}));
    assert!(err && text.contains("you are not a member of"), "{text}");
    // Memberships in public: none yet.
    assert_eq!(c.json("org_list", json!({})), json!({"organizations": []}));
    // An account that keeps an organization record is one, so ending it
    // asks first.
    s.put_record(
        "dev.knotless.org",
        "self",
        json!({"$type": "dev.knotless.org", "createdAt": "2026-10-28T00:00:00Z"}),
    );
    wait_until(|| c.json("org_members", json!({}))["organization"] == true);
    let (text, err) = c.call("org_delete", json!({}));
    assert!(err && text.contains("call again with yes"), "{text}");
    let ended = c.json("org_delete", json!({"yes": true}));
    assert_eq!(ended["changed"], json!({"removed": []}), "{ended}");
    // A join record left behind goes, though no gateway takes the rest.
    let joined = json!({"$type": "dev.knotless.orgAcceptance", "subject": other.did, "createdAt": "2026-10-28T00:00:00Z"});
    s.put_record("dev.knotless.orgAcceptance", &other.did, joined);
    let left = c.json("org_leave", json!({"org": other.handle}));
    assert_eq!(left["changed"]["left"], json!(other.handle));
    let warning = left["changed"]["warning"].as_str().unwrap_or_default();
    assert!(warning.contains("acts through no gateway"), "{left}");
    assert!(s.records("dev.knotless.orgAcceptance").is_empty());
}

/// Pulls, issues, a pull's diff and files are resources as well as tools,
/// by URIs that mirror their pages, each read as its tool answers.
#[test]
fn agents_read_resources() {
    let rt = tokio::runtime::Runtime::new().unwrap();
    let (base, _appview, _proxy) = appview(&rt, "");
    let mut owner = logged_in();
    owner.set("KNOTLESS_APPVIEW", &base);
    let c = Client::new(&owner);

    let info = c.peer.peer_info().unwrap();
    assert!(info.capabilities.resources.is_some(), "{info:?}");
    assert!(info.capabilities.tools.is_some(), "{info:?}");
    let templates = c.rt.block_on(c.peer.list_all_resource_templates()).unwrap();
    let listed: Vec<(&str, &str, Option<&str>)> = templates
        .iter()
        .map(|t| {
            assert!(t.title.is_some() && t.description.is_some(), "{t:?}");
            (
                t.name.as_str(),
                t.uri_template.as_str(),
                t.mime_type.as_deref(),
            )
        })
        .collect();
    let (json, text) = (Some("application/json"), Some("text/plain"));
    assert_eq!(
        listed,
        [
            ("pulls", "knotless://{owner}/{repo}/pulls", json),
            ("issues", "knotless://{owner}/{repo}/issues", json),
            ("pull", "knotless://{owner}/{repo}/pull/{did}/{rkey}", json),
            (
                "pull_diff",
                "knotless://{owner}/{repo}/pull/{did}/{rkey}/diff",
                text
            ),
            (
                "issue",
                "knotless://{owner}/{repo}/issue/{did}/{rkey}",
                json
            ),
            ("file", "knotless://{owner}/{repo}/file/{rev}/{+path}", text),
        ]
    );
    // Only templates: there are too many pulls and files to list.
    assert!(
        c.rt.block_on(c.peer.list_all_resources())
            .unwrap()
            .is_empty()
    );

    let repo = c_repo(&c.json("repo_create", json!({"name": "resourced"})));
    c.json(
        "repo_commit",
        json!({"repo": repo, "branch": "main", "message": "start", "changes": [
            {"path": "README.md", "content": "hello\n"},
            {"path": "logo.bin", "base64": "AAEC/w=="},
        ]}),
    );
    c.json("branch_create", json!({"repo": repo, "name": "topic/more"}));
    c.json(
        "repo_commit",
        json!({"repo": repo, "branch": "topic/more", "message": "more", "changes": [
            {"path": "docs/a b.md", "content": "on the branch\n"},
        ]}),
    );
    let opened = json!({"repo": repo, "base": "main", "head_repo": repo, "head_branch": "topic/more", "title": "More", "body": "more"});
    let pull = c.json("pull_create", opened)["uri"]
        .as_str()
        .unwrap()
        .to_string();
    let issue = c.json("issue_create", json!({"repo": repo, "title": "Less"}))["uri"]
        .as_str()
        .unwrap()
        .to_string();
    c.json(
        "comment_add",
        json!({"repo": repo, "uri": pull, "body": "looks right"}),
    );
    // The lists from the appview, once it has the pull, its comment and
    // the issue, so a tool and its resource read the same.
    let all = |tool: &str| c.json(tool, json!({"repo": repo}));
    wait_until(|| {
        let shown = c.json("pull_show", json!({"repo": repo, "uri": pull}));
        let pulls = all("pull_list");
        pulls[0]["comments"] == 1
            && all("issue_list").as_array().unwrap().len() == 1
            && shown["comments"]
                .as_array()
                .is_some_and(|said| said.len() == 1)
    });

    // Each as its tool answers, JSON or text.
    let page = |uri: &str| {
        let parts: Vec<&str> = uri.strip_prefix("at://").unwrap().split('/').collect();
        format!("{}/{}", parts[0], parts[2])
    };
    let url = format!("knotless://{repo}");
    let as_tool = |uri: String, tool: &str, args: Value| {
        let read = c.read(&uri).unwrap();
        assert_eq!(read["uri"], uri.as_str());
        let said = c.ok(tool, args);
        match read["mimeType"].as_str().unwrap() {
            "application/json" => {
                let got: Value = serde_json::from_str(read["text"].as_str().unwrap()).unwrap();
                assert_eq!(got, serde_json::from_str::<Value>(&said).unwrap(), "{uri}");
            }
            mime => {
                assert_eq!(mime, "text/plain", "{uri}");
                assert_eq!(read["text"], said.as_str(), "{uri}");
            }
        }
        read
    };
    let subject = json!({"repo": repo, "uri": pull});
    as_tool(format!("{url}/pulls"), "pull_list", json!({"repo": repo}));
    as_tool(format!("{url}/issues"), "issue_list", json!({"repo": repo}));
    let shown = as_tool(
        format!("{url}/pull/{}", page(&pull)),
        "pull_show",
        subject.clone(),
    );
    assert!(shown["text"].as_str().unwrap().contains("looks right"));
    let diff = as_tool(
        format!("{url}/pull/{}/diff", page(&pull)),
        "pull_diff",
        subject,
    );
    assert!(
        diff["text"]
            .as_str()
            .unwrap()
            .contains("  1 | +on the branch")
    );
    as_tool(
        format!("{url}/issue/{}", page(&issue)),
        "issue_show",
        json!({"repo": repo, "uri": issue}),
    );
    // A branch's `/` in the revision, and a space in the path, escaped as a
    // template's expansion escapes them; the owner by DID, its `:` too.
    let did = owner.account.did.replace(':', "%3A");
    let read = as_tool(
        format!("knotless://{did}/resourced/file/topic%2Fmore/docs/a%20b.md"),
        "repo_read",
        json!({"repo": repo, "rev": "topic/more", "path": "docs/a b.md"}),
    );
    assert_eq!(read["text"], "on the branch\n");
    // A binary file as a blob.
    let logo = c.read(&format!("{url}/file/main/logo.bin")).unwrap();
    assert_eq!(logo["blob"], "AAEC/w==");
    assert_eq!(logo["mimeType"], "application/octet-stream");

    // A read that fails says what the tool would.
    let gone = c.read(&format!("{url}/file/main/gone.md")).unwrap_err();
    let (said, err) = c.call("repo_read", json!({"repo": repo, "path": "gone.md"}));
    assert!(err);
    assert_eq!(gone.message, said);
    // A URI no template makes names those that are.
    for bad in [
        format!("https://knotless.dev/{repo}/pulls"),
        url.clone(),
        format!("{url}/pulls/"),
        format!("{url}/pull/{}/patch", page(&pull)),
        format!("{url}/issue/{}/diff", page(&issue)),
        format!("{url}/file/main"),
        format!("{url}/file/main//a"),
        format!("{url}/file/%FF/README.md"),
    ] {
        let err = c.read(&bad).unwrap_err();
        assert_eq!(
            err.code,
            rmcp::model::ErrorCode::RESOURCE_NOT_FOUND,
            "{bad}"
        );
        assert!(
            err.message.contains(&bad)
                && err
                    .message
                    .contains("knotless://{owner}/{repo}/file/{rev}/{+path}"),
            "{err:?}"
        );
    }
}