Function load_selected_agent_identity

atomic-agent/src/identity.rs:177–206

The currently-selected delegated agent identity, if one resolves. Shared by the author path ([`delegated_agent_author`]) and the signing path ([`resolve_turn_signer`]) so attribution and proof can never name different identities: same name chain (explicit option, else [`AGENT_IDENTITY_ENV`]), same store, same refusal of human identities. Returns the store alongside the identity — callers need it

(
    agent_identity: Option<&str>,
    identity_dir: Option<&Path>,
)

/// Returns the store alongside the identity — callers need it to load the
/// keypair without re-opening (and possibly disagreeing about) the store.
fn load_selected_agent_identity(
    agent_identity: Option<&str>,
    identity_dir: Option<&Path>,
) -> Option<(atomic_identity::IdentityStore, atomic_identity::Identity)> {
    let name = agent_identity
        .map(str::to_string)
        .or_else(|| std::env::var(AGENT_IDENTITY_ENV).ok())
        .map(|n| n.trim().to_string())
        .filter(|n| !n.is_empty())?;

    let store = open_identity_store(identity_dir)?;

    let identity = match store.load_by_name(&name) {
        Ok(identity) => identity,
        Err(e) => {
            log::debug!("Agent identity '{name}' not usable ({e}); falling back to plus-tag");
            return None;
        }
    };

    // A human identity here would silently sign agent work as the human with
    // no delegation behind it — worse than the plus-tag fallback, which at
    // least does not claim to be keyed to an agent.
    if !identity.identity_type.is_delegated() && !identity.identity_type.is_agent() {
        log::debug!("'{name}' is not an agent identity; falling back to plus-tag");
        return None;
    }

    Some((store, identity))
}

/// Resolve the signer for a recorded turn: the identity whose public key
/// the header author claims.