Struct ContinuationState 

pub struct ContinuationState {

    pub previous_status: Option<DevelopmentStatus>,
    pub previous_summary: Option<String>,
    pub previous_files_changed: Option<Vec<String>>,
    pub previous_next_steps: Option<String>,
    pub continuation_attempt: u32,
    pub invalid_output_attempts: u32,
    pub context_write_pending: bool,
    pub context_cleanup_pending: bool,
    pub xsd_retry_count: u32,
    pub xsd_retry_pending: bool,
    pub xsd_retry_session_reuse_pending: bool,
    pub last_xsd_error: Option<String>,
    pub last_review_xsd_error: Option<String>,
    pub last_fix_xsd_error: Option<String>,
    pub same_agent_retry_count: u32,
    pub same_agent_retry_pending: bool,
    pub same_agent_retry_reason: Option<SameAgentRetryReason>,
    pub continue_pending: bool,
    pub current_artifact: Option<ArtifactType>,
    pub max_xsd_retry_count: u32,
    pub max_same_agent_retry_count: u32,
    pub max_continue_count: u32,
    pub fix_status: Option<FixStatus>,
    pub fix_previous_summary: Option<String>,
    pub fix_continuation_attempt: u32,
    pub fix_continue_pending: bool,
    pub max_fix_continue_count: u32,
    pub last_effect_kind: Option<String>,
    pub consecutive_same_effect_count: u32,
    pub max_consecutive_same_effect: u32,
}

Continuation state for development iterations.

Tracks context from previous attempts within the same iteration to enable continuation-aware prompting when status is “partial” or “failed”.

When Fields Are Populated

• previous_status: Set when DevelopmentIterationContinuationTriggered event fires
• previous_summary: Set when DevelopmentIterationContinuationTriggered event fires
• previous_files_changed: Set when DevelopmentIterationContinuationTriggered event fires
• previous_next_steps: Set when DevelopmentIterationContinuationTriggered event fires
• continuation_attempt: Incremented on each continuation within same iteration

Reset Triggers

The continuation state is reset (cleared) when:

• A new iteration starts (DevelopmentIterationStarted event)
• Status becomes “completed” (ContinuationSucceeded event)
• Phase transitions away from Development

Fields

previous_status: Option<DevelopmentStatus>

Status from the previous attempt (“partial” or “failed”).

previous_summary: Option<String>

Summary of what was accomplished in the previous attempt.

previous_files_changed: Option<Vec<String>>

Files changed in the previous attempt.

previous_next_steps: Option<String>

Agent’s recommended next steps from the previous attempt.

continuation_attempt: u32

Current continuation attempt number (0 = first attempt, 1+ = continuation).

invalid_output_attempts: u32

Count of invalid XML outputs for the current iteration.

context_write_pending: bool

Whether a continuation context write is pending.

context_cleanup_pending: bool

Whether a continuation context cleanup is pending.

xsd_retry_count: u32

Count of XSD validation retry attempts for current artifact.

Tracks how many times we’ve retried with the same agent/session due to XML parsing or XSD validation failures. Reset when switching agents, artifacts, or on successful validation.

xsd_retry_pending: bool

Whether an XSD retry is pending (validation failed, need to retry).

Set to true when XsdValidationFailed event fires. Cleared when retry attempt starts or max retries exceeded.

xsd_retry_session_reuse_pending: bool

Whether the next agent invocation should reuse the last session id.

XSD retry is derived via xsd_retry_pending, but xsd_retry_pending is cleared as soon as the retry prompt is prepared to avoid re-deriving the prepare-prompt effect. This flag preserves the “reuse session id” signal for the subsequent invocation effect.

last_xsd_error: Option<String>

Last validation error message for XSD retry prompts (commit phase).

This is set when validation fails and cleared when the retry attempt starts.

last_review_xsd_error: Option<String>

Last XSD validation error for review issues XML (used in XSD retry prompt).

This is set when review validation fails and cleared when transitioning away from review or when validation succeeds.

last_fix_xsd_error: Option<String>

Last XSD validation error for fix result XML (used in XSD retry prompt).

This is set when fix validation fails and cleared when transitioning away from fix or when validation succeeds.

same_agent_retry_count: u32

Count of same-agent retry attempts for transient invocation failures.

This is intentionally separate from XSD retry, which is only for invalid XML outputs.

same_agent_retry_pending: bool

Whether a same-agent retry is pending.

Set to true by the reducer when a transient invocation failure occurs (timeout/internal). Cleared when the retry attempt starts or when switching agents.

same_agent_retry_reason: Option<SameAgentRetryReason>

The reason for the pending same-agent retry, for prompt rendering.

continue_pending: bool

Whether a continuation is pending (output valid but work incomplete).

Set to true when agent output indicates status is “partial” or “failed”. Cleared when continuation attempt starts or max continuations exceeded.

current_artifact: Option<ArtifactType>

Current artifact type being processed.

Set at the start of each phase to track which XML artifact is expected. Used for appropriate retry prompts and error messages.

max_xsd_retry_count: u32

Maximum XSD retry attempts (default 10).

Loaded from unified config. After this many retries, falls back to agent chain advancement.

max_same_agent_retry_count: u32

Maximum same-agent retry attempts for invocation failures that should not immediately trigger agent fallback (default 2).

This is a failure budget for the current agent. For example, with a value of 2:

• 1st failure → retry the same agent
• 2nd failure → fall back to the next agent

max_continue_count: u32

Maximum continuation attempts (default 3).

Loaded from unified config. After this many continuations, marks iteration as complete (even if status is partial/failed).

fix_status: Option<FixStatus>

Status from the previous fix attempt.

fix_previous_summary: Option<String>

Summary from the previous fix attempt.

fix_continuation_attempt: u32

Current fix continuation attempt number (0 = first attempt, 1+ = continuation).

fix_continue_pending: bool

Whether a fix continuation is pending (output valid but work incomplete).

Set to true when fix output indicates status is “issues_remain”. Cleared when continuation attempt starts or max continuations exceeded.

max_fix_continue_count: u32

Maximum fix continuation attempts (default 3).

After this many continuations, proceeds to commit even if issues remain.

last_effect_kind: Option<String>

Loop detection: last effect executed (for detecting repeats).

consecutive_same_effect_count: u32

Loop detection: count of consecutive identical effects.

max_consecutive_same_effect: u32

Maximum consecutive identical effects before triggering recovery.

Implementations

impl ContinuationState

pub fn new() -> Self

Create a new empty continuation state.

pub fn with_limits( max_xsd_retry_count: u32, max_continue_count: u32, max_same_agent_retry_count: u32, ) -> Self

Create continuation state with custom limits (for config loading).

pub fn with_max_xsd_retry(self, max_xsd_retry_count: u32) -> Self

Builder: set max XSD retry count.

Use 0 to disable XSD retries (immediate agent fallback on validation failure).

pub fn with_max_same_agent_retry(self, max_same_agent_retry_count: u32) -> Self

Builder: set max same-agent retry count for transient invocation failures.

Use 0 to disable same-agent retries (immediate agent fallback on timeout/internal error).

pub fn is_continuation(&self) -> bool

Check if this is a continuation attempt (not the first attempt).

pub fn reset(&self) -> Self

Reset the continuation state for a new iteration or phase transition.

This performs a hard reset of ALL continuation and retry state, preserving only the configured limits (max_xsd_retry_count, max_continue_count, max_fix_continue_count).

What gets reset

• continuation_attempt -> 0
• continue_pending -> false
• invalid_output_attempts -> 0
• xsd_retry_count -> 0
• xsd_retry_pending -> false
• fix_continuation_attempt -> 0
• fix_continue_pending -> false
• fix_status -> None
• current_artifact -> None
• previous_status, previous_summary, etc. -> defaults

Usage

Call this when transitioning to a completely new phase or iteration where prior continuation/retry state should not carry over. For partial resets (e.g., resetting only fix continuation while preserving development continuation state), use field-level updates instead.

pub fn with_artifact(&self, artifact: ArtifactType) -> Self

Set the current artifact type being processed.

pub fn trigger_xsd_retry(&self) -> Self

Mark XSD validation as failed, triggering a retry.

For XSD retry, we want to re-invoke the same agent in the same session when possible, to keep retries deterministic and to preserve provider-side context.

pub fn clear_xsd_retry_pending(&self) -> Self

Clear XSD retry pending flag after starting retry.

pub fn xsd_retries_exhausted(&self) -> bool

Check if XSD retries are exhausted.

pub fn trigger_same_agent_retry(&self, reason: SameAgentRetryReason) -> Self

Mark a same-agent retry as pending for a transient invocation failure.

pub fn clear_same_agent_retry_pending(&self) -> Self

Clear same-agent retry pending flag after starting retry.

pub fn same_agent_retries_exhausted(&self) -> bool

Check if same-agent retries are exhausted.

pub fn trigger_continue(&self) -> Self

Mark continuation as pending (output valid but work incomplete).

pub fn clear_continue_pending(&self) -> Self

Clear continue pending flag after starting continuation.

pub fn continuations_exhausted(&self) -> bool

Check if continuation attempts are exhausted.

Returns true when continuation_attempt >= max_continue_count.

Semantics

The continuation_attempt counter tracks how many times work has been attempted:

• 0: Initial attempt (before any continuation)
• 1: After first continuation
• 2: After second continuation
• etc.

With max_continue_count = 3:

• Attempts 0, 1, 2 are allowed (3 total)
• Attempt 3+ triggers exhaustion

Naming Note

The field is named max_continue_count rather than max_total_attempts because it historically represented the maximum number of continuations. The actual semantics are “maximum total attempts including initial”.

pub fn trigger_continuation( &self, status: DevelopmentStatus, summary: String, files_changed: Option<Vec<String>>, next_steps: Option<String>, ) -> Self

Trigger a continuation with context from the previous attempt.

Sets both context_write_pending (to write continuation context) and continue_pending (to trigger the continuation flow in orchestration).

pub fn fix_continuations_exhausted(&self) -> bool

Check if fix continuations are exhausted.

Semantics match continuations_exhausted(): with default max_fix_continue_count of 3, attempts 0, 1, 2 are allowed (3 total), attempt 3+ is exhausted.

pub fn trigger_fix_continuation( &self, status: FixStatus, summary: Option<String>, ) -> Self

Trigger a fix continuation with status context.

pub fn clear_fix_continue_pending(&self) -> Self

Clear fix continuation pending flag after starting continuation.

pub fn reset_fix_continuation(&self) -> Self

Reset fix continuation state (e.g., when entering a new review pass).

pub fn update_loop_detection_counters( &self, current_fingerprint: String, ) -> Self

Update loop detection counters based on the current effect fingerprint.

This method updates last_effect_kind and consecutive_same_effect_count based on whether the current effect fingerprint matches the previous one.

Returns

A new ContinuationState with updated loop detection counters.

Behavior

• If current_fingerprint equals last_effect_kind: increment consecutive_same_effect_count
• Otherwise: reset consecutive_same_effect_count to 1 and update last_effect_kind

pub fn is_loop_detected(&self) -> bool

Check if loop detection threshold has been exceeded.

Returns true if consecutive_same_effect_count >= max_consecutive_same_effect.

Trait Implementations

impl Clone for ContinuationState

fn clone(&self) -> ContinuationState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ContinuationState

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

Formats the value using the given formatter.

impl Default for ContinuationState

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ContinuationState

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ContinuationState

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ContinuationState

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ContinuationState

impl StructuralPartialEq for ContinuationState