Who did the work: via AGENT in log and show, delegates by name 5cde7882d767

        // The owner's own handle (its key directory was fixed at `setup`;

        // the environment's `OXY_HOME` may have moved since).

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

- **Badges (implemented 2026-10-04):** a change signed by a delegate

  shows its author and, beside it, `via NAME` with an `agent` badge: in

  history rows on the hub, as a `via` row under the author on the change

  page (`↳ Antigravity <…> · delegate for changes, until … · key …`),

  under the author in Contributors ("via Antigravity 3"), as `via` in

  the API's change summaries, and the same in `oxy log` (`via NAME`) and

  `oxy show` (the `via` row). The author stays the human; the agent is

  the instrument, and a revoked or withdrawn delegation turns the badge

  red. The hub also links a rotated identity to its owner's account by

  itself when a push brings it, so delegating never breaks attribution.

use oxy_core::hash::{ChangeHash, KeyId};

/// Who signed for the author when it was not the author: a delegate such

/// as an agent (`author.signer`), with the delegation that let it.

#[derive(Clone, Debug)]

pub struct Via {

    pub name: String,

    pub email: String,

    pub key: KeyId,

    /// The delegation as the author's identity lists it, if it still does.

    pub scope: Option<String>,

    pub expires: Option<u64>,

    pub revoked: bool,

}

impl Via {

    /// `↳ Antigravity <[email protected]> · delegate for changes, until … · key 3195…`

    pub fn line(&self) -> String {

        let delegation = match (&self.scope, self.revoked) {

            (_, true) => ui::err("delegation revoked"),

            (Some(scope), false) => ui::dim(format!(

                "delegate for {scope}{}",

                self.expires

                    .map(|e| format!(", until {}", when(e)))

                    .unwrap_or_default()

            )),

            (None, false) => ui::warn("not a delegate of the author now"),

        };

        format!(

            "{} {} <{}> · {} · key {}",

            ui::glyph("↳", "->"),

            ui::author(&self.name),

            self.email,

            delegation,

            ui::hash(self.key.short(12))

        )

    }

}

/// The delegate that signed for `author`, when one did. `None` when the

/// author signed, or nothing valid did.

pub fn via(repo: &Repo, status: &SignatureStatus, author: &KeyId) -> Option<Via> {

    match status {

        SignatureStatus::Valid {

            key,

            name,

            email,

            revoked,

            ..

        } if !author.is_zero() && key != author => {

            let entry = repo

                .identity(author)

                .ok()

                .and_then(|a| a.delegate(key).copied());

            Some(Via {

                name: name.clone(),

                email: email.clone(),

                key: *key,

                scope: entry.map(|d| d.scope.to_string()),

                expires: entry.and_then(|d| d.expires),

                revoked: *revoked || entry.is_none(),

            })

        }

        _ => None,

    }

}

/// A compact, styled authentication marker for log lines, from a status

/// already in hand (the caller also reads who signed, see [`via`]).

pub fn signature_mark_of(status: &SignatureStatus) -> String {

    match status {

            if *sealed { "sealed" } else { "signed" }

            if *sealed { "sealed" } else { "signed" }

    }

/// Print the delegates, one per line: who, their key, what they may do

/// and until when, so an agent's name is seen, not only its key.

fn print_delegates(repo: &Repo, delegates: &[Delegate]) {

    if delegates.is_empty() {

        return;

    }

    println!("{}", ui::kv("delegates", delegates.len().to_string()));

    let now = Hlc::now().wall_ms;

    for d in delegates {

        let who = repo

            .identity(&d.key)

            .map(|i| format!("{} <{}>", i.name, i.email))

            .unwrap_or_else(|_| "(unknown identity)".into());

        let until = match d.expires {

            Some(e) if now > e => ui::err(format!("expired {}", ui::ago(e))),

            Some(e) => ui::dim(format!("until {}", when(e))),

            None => String::new(),

        };

        println!(

            "    {}  {}  {} {}",

            ui::author(who),

            ui::hash(d.key.short(12)),

            ui::dim(d.scope.to_string()),

            until

        );

    }

fn report_rotation(repo: &Repo, r: &Rotation, verb: &str) -> Result<()> {

    print_delegates(repo, &r.identity.delegates);

    print_delegates(&repo, &id.delegates);

    report_rotation(&repo, &r, "Rotated")?;

    report_rotation(&repo, &r, "Renewed")?;

        report_rotation(&repo, &r, "Undelegated")?;

    report_rotation(&repo, &r, "Delegated")?;

    report_rotation(&repo, &r, "Undelegated")?;

    author_name, deps_line, deps_of, plural, short_id, signature_line, signature_mark_of,

    subject_of, via, when,

        (

            "via",

            match via(

                repo,

                &repo.authenticate_change_known(&e.hash, Some(c))?,

                &c.author,

            ) {

                Some(v) => json::obj([

                    ("name", json::s(&v.name)),

                    ("email", json::s(&v.email)),

                    ("key", json::s(&v.key.to_hex())),

                    ("scope", json::opt(v.scope.as_deref(), json::s)),

                    ("expires_ms", json::opt(v.expires, json::n)),

                    ("revoked", json::b(v.revoked)),

                ]),

                None => "null".to_string(),

            },

        ),

            let status = repo.authenticate_change_known(&e.hash, Some(c))?;

            if let Some(agent) = via(&repo, &status, &c.author) {

                head.push(ui::dim(format!("via {}", agent.name)));

            }

            head.push(signature_mark_of(&status));

    let meta = oxy_core::state::ChangeMeta::of(&c);

    let status = repo.authenticate_change_known(&h, Some(&meta))?;

    println!("{}", ui::kv("author", ui::author(author_name(repo, &meta))));

    if let Some(agent) = via(repo, &status, &meta.author) {

        println!("{}", ui::kv("via", agent.line()));

    }