Enum Agent 

pub enum Agent {
    ClaudeCode,
    Codex,
    Droid,
    Copilot,
    Pi,
}

Which agent to run, by name.

It used to be a free argv, and that was the wrong shape. The grouping stage does not merely spawn a process: it hands the agent a tool allowlist, a fetch command and a prompt written for what that agent can do (ADR 0022). An arbitrary argv gets the prompt and none of the rest, so it was a knob that looked like it worked. A name selects an invocation this crate builds whole, and adding an agent is adding a variant here.

The name also answers what a reviewer is shown while they wait — the argv never could, at four times the width of the line it had.

Four of the five keep the model read-only; Pi does not (ADR 0033). Read Agent::read_only and ReadOnly::is_enforced before choosing one.

Variants

ClaudeCode

Headless claude, read-only by tool allowlist (ADR 0022).

Codex

Headless codex exec, read-only by OS sandbox (Seatbelt, bubblewrap).

Droid

Headless droid exec, read-only by default — the tier is what we do not pass.

Copilot

Headless copilot, read-only by tool allowlist and an explicit deny.

Pi

Headless pi, read-only is NOT enforced (ADR 0033).

Pi ships no sandbox and no per-command allowlist, and its -t flag toggles whole tools. The model needs bash to run the fetch command and git diff, and bash also lets it write, commit and push. Nothing but the prompt stops it. Choose this agent only knowing that.

Implementations

impl Agent

pub const ALL: &'static [Agent] = <Agent as strum::VariantArray>::VARIANTS

Every variant, in declaration order, from strum’s VariantArray: the derive is what keeps the list whole, so there is no hand-kept array to forget a variant in.

pub fn key(self) -> &'static str

The name this answers to in the config file. strum’s IntoStaticStr, renamed as serde renames it; every_*_name_round_trips in this module pins the two derives to the same spelling.

pub fn proven(self) -> bool

Whether anyone has ever run this agent’s command line.

Not a quality judgement — a claim about provenance, and the only honest one this crate can make. Every argv here is written from its agent’s documentation, and a test can assert the string this crate builds but never that the CLI on the other end accepts it. CI cannot either: the binary is not installed and its flags move between releases.

true means dfr agents --probe passed all four checks against the real CLI, and the argv is in this repository because of that run.

false means likely wrong, not merely unchecked. Of the three checked so far, two were broken: Claude Code’s allowlist did not bind without --permission-mode default, and Codex was passing --ask-for-approval, which its exec subcommand rejects outright. Both came from documentation that was accurate about the product and wrong about the entry point. Nothing suggests the unchecked two are better.

A caller that offers a user this list must say so, for the same reason it must say what Agent::read_only answers: the person choosing is the person who carries it.

This flips when someone runs the probe and the argv lands — never because it looks right.

pub fn read_only(self) -> ReadOnly

What stops this agent writing, if anything.

A caller that shows a user the list of agents MUST show this too. The person picking a name is the person who needs to know, and exactly one answer here is ReadOnly::NotEnforced.

Trait Implementations

impl Clone for Agent

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Agent

impl Debug for Agent

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Agent

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Agent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Agent

impl<'_derivative_strum> From<&'_derivative_strum Agent> for &'static str

fn from(x: &'_derivative_strum Agent) -> &'static str

Converts to this type from the input type.

impl From<Agent> for &'static str

fn from(x: Agent) -> &'static str

Converts to this type from the input type.

impl PartialEq for Agent

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Agent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Agent

impl VariantArray for Agent

const VARIANTS: &'static [Self]