author.signer: an agent signs its owner's changes with its own key ff1a64f81c1c

    /// `author.signer` (or `$OXY_SIGNER`): the key that signs and seals in

    /// place of `author.key`, whose identity lists it as a delegate. An

    /// agent sets it to its own key, so its changes carry the human as

    /// author and the agent's signature (spec §14.2, agent workflows §2).

    pub signer_key: Option<KeyId>,

            signer_key: std::env::var("OXY_SIGNER")

                .ok()

                .and_then(|v| KeyId::from_hex(&v)),

            "author.signer" => {

                self.signer_key = if value.is_empty() {

                    None

                } else {

                    Some(KeyId::from_hex(value).ok_or_else(|| {

                        RepoError::Msg("author.signer must be a 64-character hex KeyId".into())

                    })?)

                }

            }

    /// Agent doc §2 end to end from the command line's point of view: the

    /// agent's key is a changes-only delegate, and `author.signer` makes

    /// the owner's checkout sign with it while `author.key` stays the

    /// owner, so a commit carries the owner as author and the agent's

    /// signature, and a reference attestation by the agent is refused.

    #[test]

    fn an_agent_signs_its_owner_s_changes_through_author_signer() {

        let dir = tempfile::tempdir().unwrap();

        let (host, mut user, _, _, _) = setup(dir.path(), true, false);

        // The owner's keys are in the hermetic home; keep its path, since

        // another test module may point `OXY_HOME` elsewhere meanwhile.

        let owner_home = std::env::var("OXY_HOME").unwrap();

        let owner = user.config.author_key.unwrap();

        // The agent makes its own key in its own home; the owner delegates.

        let agent_home = dir.path().join("agent-home");

        let mut agent_repo = Repo::init(&dir.path().join("agent-work"))

            .unwrap()

            .with_home(agent_home.clone());

        let (agent, agent_id) = agent_repo

            .create_identity("aider on a laptop", "agent@example", IdentityScope::User)

            .unwrap();

        user.delegate_add(agent_id.clone(), Scope::CHANGES, None)

            .unwrap();

        assert!(user.push("origin", false).unwrap().iter().all(|x| x.ok));

        let owner = {

            let _ = owner;

            user.config.author_key.unwrap()

        };

        // The owner's checkout, as the agent runs it: the agent's keys,

        // the owner as author, the agent as signer.

        // (The signer is the agent's own setting, in its user config: the

        // checkout's `author.key` is the owner's, in the repository.)

        let work = dir.path().join("work");

        let mut as_agent = Repo::open(&work).unwrap().with_home(agent_home);

        as_agent

            .set_user_config("author.signer", &agent.to_hex())

            .unwrap();

        as_agent.set_user_config("core.sign", "change").unwrap();

        assert_eq!(as_agent.config.author_key, Some(owner));

        assert_eq!(as_agent.signing_key(), Some(agent));

        write(&work, "a.txt", b"by the agent\n");

        as_agent.snapshot("t").unwrap();

        let h = as_agent.commit("Agent: edit a", &[]).unwrap();

        let meta = as_agent.store().get_change_meta(&h).unwrap();

        assert_eq!(meta.author, owner, "the owner stays the author");

        assert!(matches!(

            as_agent.verify_change(&h).unwrap(),

            SignatureStatus::Valid { key, .. } if key == agent

        ));

        assert_eq!(as_agent.revset("delegated()").unwrap().hashes, vec![h]);

        // The agent cannot push: its attestation of the reference is

        // refused under the policy. The owner can.

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

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

        assert!(!host.bookmark_heads().unwrap().contains(&h));

        let owner_repo = Repo::open(&work).unwrap().with_home(owner_home);

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

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

        assert!(host.bookmark_heads().unwrap().contains(&h));

        assert!(matches!(

            host.authenticate_change(&h).unwrap(),

            SignatureStatus::Valid { key, .. } if key == agent

        ));

    }

    /// The key this repository signs with: `author.signer` when set (an

    /// agent's own key, acting for the author), else `author.key`.

    pub fn signing_key(&self) -> Option<KeyId> {

        self.config.signer_key.or(self.config.author_key)

    }

    /// The secret key for `author.signer`, else `author.key`, if configured

    /// and present on disk. The identity object is kept beside the secret

    /// so a repository that has never seen it (a fresh clone) can store it

    /// when it first signs.

        let Some(key) = self.signing_key() else {

  which agent made the change, which a marker could not. In practice

  (implemented 2026-10-04): the agent's keys live in its own `$OXY_HOME`,

  and its user config (or `$OXY_SIGNER`) sets `author.signer` to its

  KeyId; the checkout's `author.key` stays the human's, so `oxy commit`

  run by the agent carries the human as author and the agent's

  signature, and `oxy log -r 'delegated()'` lists what the agent did.

#   …and in the agent's own shell: OXY_HOME=~/.oxy-agent oxy config --user author.signer <its key>

| `author.signer` | the key that signs instead of `author.key`: an agent's own key, which your identity lists as a delegate (also `$OXY_SIGNER`) |

| `~/.config/oxy/config.toml` | User settings, the same keys as `.oxy/config`: `author.name`, `author.email`, `author.key`, `author.signer` (the key that signs and seals in place of `author.key`, which must list it as a delegate: an agent's own key; also `$OXY_SIGNER`), `core.sign`, and `remote.<name>.token`; also `auth.helper`. Overridden by `$OXY_HOME/config.toml` when `$OXY_HOME` is set. |