Struct AutonomousLoop 

pub struct AutonomousLoop {

    pub id: String,
    pub task: String,
    pub iteration: u8,
    pub max_iterations: u8,
    pub phase: LoopPhase,
    pub started: bool,
    pub emergency_stopped: bool,
    pub tasks: Vec<LoopTask>,
    pub batches: Vec<TaskBatch>,
    pub issues: Vec<Issue>,
    pub last_verification: Option<VerificationResult>,
    pub last_commit: Option<String>,
    pub git_clean: bool,
    pub blocker: Option<String>,
    pub created_at: String,
    pub updated_at: String,
}

The autonomous development loop state machine.

Tracks the full lifecycle of an autonomous development task across multiple iterations of the Design → Plan → Implement → Verify → ReValidate → Fix loop.

Usage

let mut al = AutonomousLoop::new("Implement user authentication");
al.start()?;

// Design phase
al.advance()?; // → Plan

// Plan phase — add tasks and compute batches
al.add_task(LoopTask::new("T1", "Create auth module").touches("src/auth.rs"));
al.add_task(LoopTask::new("T2", "Add login route").depends_on("T1"));
al.compute_batches()?;
al.advance()?; // → Implement

// ... execute batches ...
al.advance()?; // → Verify

Fields

id: String

Unique loop instance ID.

task: String

The task description.

iteration: u8

Current iteration (1-based).

max_iterations: u8

Maximum iterations allowed.

phase: LoopPhase

Current phase.

started: bool

Whether the loop has been started.

emergency_stopped: bool

Whether the loop has been forcefully stopped.

tasks: Vec<LoopTask>

All tasks in the plan.

batches: Vec<TaskBatch>

Computed execution batches.

issues: Vec<Issue>

Issues found across all iterations.

last_verification: Option<VerificationResult>

Latest verification result.

last_commit: Option<String>

Most recent commit hash.

git_clean: bool

Whether the git working tree is clean.

blocker: Option<String>

Any blocking condition preventing progress.

created_at: String

Creation timestamp.

updated_at: String

Last update timestamp.

Implementations

impl AutonomousLoop

pub fn new(task: impl Into<String>) -> Self

Create a new autonomous loop for the given task.

pub fn with_max_iterations(self, max: u8) -> Self

Set the maximum number of iterations.

pub fn start(&mut self) -> Result<()>

Start the loop (transitions to iteration 1, Design phase).

pub fn emergency_stop(&mut self, reason: impl Into<String>)

Emergency stop — halts the loop immediately.

pub fn advance(&mut self) -> Result<LoopPhase>

Advance to the next phase.

Follows the standard loop flow:

• After ReValidate with no confirmed issues → Done
• After ReValidate with confirmed issues → Fix → Verify (new iteration)
• After Verify with no issues → Done
• After Verify with issues → ReValidate

pub fn set_phase(&mut self, phase: LoopPhase)

Jump to a specific phase (for recovery or testing).

pub fn add_task(&mut self, task: LoopTask)

Add a task to the plan.

pub fn get_task(&self, id: &str) -> Option<&LoopTask>

Get a task by ID.

pub fn get_task_mut(&mut self, id: &str) -> Option<&mut LoopTask>

Get a mutable reference to a task by ID.

pub fn compute_batches(&mut self) -> Result<()>

Compute execution batches from the current task list.

Groups tasks into batches using topological ordering. Each batch contains tasks whose dependencies are all in earlier batches. Tasks within a batch that touch overlapping files are flagged as having conflicts.

Uses Kahn’s algorithm for topological sorting, grouping tasks by their dependency depth level.

pub fn next_pending_batch(&self) -> Option<&TaskBatch>

Get the next pending batch, if any.

pub fn get_batch_mut(&mut self, index: usize) -> Option<&mut TaskBatch>

Get a mutable reference to a batch by index.

pub fn completed_batch_count(&self) -> usize

Count completed batches.

pub fn total_batch_count(&self) -> usize

Count total batches.

pub fn add_issue(&mut self, issue: Issue)

Add an issue found during verification.

pub fn confirmed_issues(&self) -> Vec<&Issue>

Get all confirmed, unfixed issues.

pub fn issues_by_verdict(&self, verdict: IssueVerdict) -> usize

Count issues by verdict.

pub fn fixed_issue_count(&self) -> usize

Count fixed issues.

pub fn record_verification(&mut self, result: VerificationResult)

Record a verification result.

pub fn is_clean(&self) -> bool

Whether the current state is “clean” (no unfixed confirmed issues, all verification gates passed).

pub fn record_commit(&mut self, hash: impl Into<String>)

Record a commit hash.

pub fn set_git_clean(&mut self, clean: bool)

Set the git clean status.

pub fn status(&self) -> LoopStatus

Produce a serializable status snapshot.

pub fn diagnostic(&self) -> String

Produce a diagnostic report when the loop hits max iterations or emergency stop.

Trait Implementations

impl Clone for AutonomousLoop

fn clone(&self) -> AutonomousLoop

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for AutonomousLoop

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AutonomousLoop

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for AutonomousLoop

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

where __S: Serializer,

Serialize this value into the given Serde serializer.