Send a keyless agent's grant signer with its certificate (oxygen#134) a66c05a6a881

- **An agent's changes verify in a new repository (oxygen#134):** a keyless agent's change in a repository its owner had never pushed to read INVALID ("grant is by an unknown author"). The hub now sends the grant's signer with each certificate, and with oxy's fix the agent keeps it and pushes it beside the certificate, so the repository can check the grant.

    /// For an agent's certificate, the identity that signed its grant

    /// (base64), so a repository that never saw the owner's current key can

    /// check the grant, and pass it on with its push (oxygen#134).

    #[serde(skip_serializing_if = "Option::is_none")]

    pub grantor_identity: Option<String>,

    };

    // The grant's signer, as linked to its account (the grant was checked

    // against it when it was made).

    let grantor_identity = match &cert.grant {

        Some(g) => db::accounts::identity_by_key(&app.db, &g.grant.grantor.to_hex())

            .await

            .ok()

            .flatten()

            .map(|l| oxy_core::dsse::base64(&l.object)),

        None => None,

    Ok(Json(CertifyResponse {

        certificate: oxy_core::dsse::base64(&signed.encode()),

        subject: proven.subject,

        expires_ms: expires,

        grantor_identity,

    }))

    // oxygen#134: in a repository that has never seen Andy's identity, the

    // agent's change still verifies, locally and on the hub: the grant's

    // signer comes with the certificate and travels with the push.

    create(&h.app, "andy", "fresh").await;

    let fresh_url = format!("{}/andy/fresh", h.base);

    let fresh_dir = work.path().join("claude-fresh");

    let mut fresh = client(&fresh_url, &fresh_dir).with_home(agent_home.clone());

    fresh.config.set("remote.origin.token", &token).unwrap();

    fresh.save_config().unwrap();

    fresh.set_user_config("author.key", &andy_key.to_hex()).unwrap();

    fresh.set_user_config("author.signer", "keyless").unwrap();

    assert!(fresh.store().get_identity(&andy_key).is_err(), "the fresh repository has never seen Andy");

    write(&fresh_dir, "first.txt", "first\n");

    let first = fresh.commit("First, by the agent", &[]).unwrap();

    let r = fresh.push("origin", false).unwrap();

    assert!(r.iter().all(|x| x.ok), "{r:?}");

    assert!(matches!(fresh.authenticate_change(&first).unwrap(), SignatureStatus::Valid { .. }), "locally");

    let fresh_host = h.app.repos.open(&RepoName::parse("andy/fresh").unwrap()).unwrap();

    assert!(

        matches!(fresh_host.authenticate_change(&first).unwrap(), SignatureStatus::Valid { sealed: true, .. }),

        "on the hub: {:?}",

        fresh_host.authenticate_change(&first).unwrap()

    );