Struct EconomicsRunArgs 

pub struct EconomicsRunArgs {
    pub repo: RepoArgs,
    pub suite: String,
    pub tasks: Vec<String>,
    pub repetitions: Vec<u32>,
    pub work_dir: Option<PathBuf>,
    pub harness: PathBuf,
    pub parallel: usize,
    pub session_timeout: u64,
    pub force: bool,
    pub dry_run: bool,
}

majordomus economics run. Spends provider usage: each selected task runs as real harness sessions with and without Majordomus installed, and each run is recorded as raw usage and gate verdicts. Empty tasks and repetitions mean every one the suite declares. --dry-run prepares each workspace, prints the harness command and removes the workspace again without starting a session, so it spends nothing. A run already recorded is skipped and never written over; --force is accepted only to be refused with the reason, because a recorded run is evidence.

use std::path::Path;
use clap::Parser;
use majordomus_cli::cli::{Cli, Command, EconomicsCommand, EconomicsRunArgs};

fn run_of(argv: &[&str]) -> EconomicsRunArgs {
    let cli = Cli::try_parse_from(argv.iter().copied()).unwrap();
    let Command::Economics(args) = cli.command else { panic!("economics") };
    let EconomicsCommand::Run(run) = args.command else { panic!("run") };
    run
}

let run = run_of(&[
    "majordomus", "economics", "run", "--task", "a", "--task", "b", "--dry-run",
]);
// repeated singular flags accumulate into the selection
assert_eq!(run.tasks, ["a", "b"]);
assert!(run.dry_run && !run.force);
// the pilot suite, every repetition, two runs at once, thirty minutes a session
assert_eq!(run.suite, "pilot");
assert!(run.repetitions.is_empty() && run.work_dir.is_none());
assert_eq!((run.parallel, run.session_timeout), (2, 1800));
assert_eq!(run.harness, Path::new("claude"));

Fields

repo: RepoArgs

Where and how the repository is read.

suite: String

The live suite to run

tasks: Vec<String>

Only this task (repeatable)

repetitions: Vec<u32>

Only this repetition (repeatable)

work_dir: Option<PathBuf>

Where transcripts go; never inside the repository. Workspaces are fresh directories of the system temporary directory, removed when their run ends

harness: PathBuf

The harness executable

parallel: usize

Runs in flight at once

session_timeout: u64

Per-session wall-clock limit, in seconds

force: bool

Refused: a recorded run is evidence and is never overwritten; exclude it in the methodology with a reason and record another repetition

dry_run: bool

Prepare every workspace and print the harness command; run nothing, spend nothing

Trait Implementations

impl Args for EconomicsRunArgs

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl Debug for EconomicsRunArgs

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

Formats the value using the given formatter.

impl FromArgMatches for EconomicsRunArgs

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.