Struct Job 

pub struct Job {
    pub name: String,
    pub description: String,
    pub args: Vec<Arg>,
    pub requires: Vec<Requirement>,
    pub agent_allow: bool,
    /* private fields */
}

One job: a named script with its metadata. The script, its interpreter language, its Opts: flags, and its extra environment are internal mechanics; a consumer deals in the name, description, declared args, dependencies, and the agent gate, and runs the job through run, run_captured, or run_agent.

Fields

name: String

The heading text (the job name).

description: String

Prose in the job body that is not a recognized Key: value line.

args: Vec<Arg>

Args: declares positional arguments in just’s syntax. A bare name is required, name='default' is optional, and a trailing *name is variadic (it collects the rest, space-joined). Each one is substituted as {{ name }} in the script and also exported as $name. Note that {{ name }} is raw text substitution, spliced in before the interpreter parses the script, so {{ name }} is NOT injection-safe for untrusted values in any language. The safe form is to read the value from the environment, never to template it: "$name" in a shell, os.environ["name"] in Python, process.env.name in Node, and so on. Reserve {{ }} for developer-authored templates. An agent-run job that raw-templates an arg is refused by run_agent.

requires: Vec<Requirement>

Requires: names the jobs this one depends on. The run* entry points resolve the transitive order (deps first, cycle and typo detected) and run each in turn, stopping on the first non-success step.

agent_allow: bool

Agent: allow opts a job in to being listed and run by an MCP or agent surface. The flag alone enforces nothing: run_agent is the gate that checks it (and agent_jobs the listing that filters on it), so a plain run or run_captured ignores it. It stays public as advisory data an embedder can read.

Implementations

impl Job

pub fn script(&self) -> &str

The script body, verbatim: the contents of the first fenced block under the heading, before any argument substitution.

Public so a consumer can show a task before running it. Knowing what a task will do should not require running it, and for a tool whose job is executing shell that is the difference between a considered decision and a leap of faith.

pub fn lang(&self) -> &str

The fenced block’s info string, which selects the interpreter. Empty means an unlabeled fence, which runs as sh.

pub fn opts(&self) -> &[String]

The task’s Opts: flags, in the order declared.

pub fn env(&self) -> &[(String, String)]

The task’s own Env: pairs. Does not include the file-level Env: hoisted to every task, which belongs to the file, not the job.

Trait Implementations

impl Clone for Job

fn clone(&self) -> Job

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Job

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

Formats the value using the given formatter.

impl Default for Job

fn default() -> Job

Returns the “default value” for a type.

impl Eq for Job

impl PartialEq for Job

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Job