Add --pause-after-step flag to implement workflow

crates/rally-core/src/lib.rs

@@ -24,6 +24,7 @@ pub enum SessionPhase {
     Implement,
     Review,
     FinalReview,
+    Paused,
     Done,
 }
 

crates/rally-workflow-build/src/lib.rs

@@ -63,6 +63,8 @@ pub struct BuildWorkflowState {
     pub reviews: Vec<ReviewState>,
     #[serde(default)]
     pub pending_feedback: Vec<String>,
+    #[serde(default)]
+    pub pause_after_step: bool,
 }
 
 impl Default for BuildWorkflowState {
@@ -75,6 +77,7 @@ impl Default for BuildWorkflowState {
             checkpoint: None,
             reviews: Vec::new(),
             pending_feedback: Vec::new(),
+            pause_after_step: false,
         }
     }
 }
@@ -107,10 +110,15 @@ impl BuildWorkflowState {
     }
 }
 
-pub fn initial_workflow_state(implementer_agent: String, steps: Vec<StepState>) -> Result<Value> {
+pub fn initial_workflow_state(
+    implementer_agent: String,
+    steps: Vec<StepState>,
+    pause_after_step: bool,
+) -> Result<Value> {
     let state = BuildWorkflowState {
         implementer_agent,
         steps,
+        pause_after_step,
         ..BuildWorkflowState::default()
     };
     encode_workflow_state(&state)
@@ -285,10 +293,35 @@ pub fn get_wait_hint(state: &SessionState, agent: &str) -> Option<String> {
                 None
             }
         }
+        SessionPhase::Paused => {
+            Some(format!(
+                "Session paused for user feedback after step {}. \
+                 Waiting for `rally build continue --session {}`.",
+                workflow_state.current_step_idx, state.name
+            ))
+        }
         _ => None,
     }
 }
 
+pub fn continue_session(state: &mut SessionState, feedback: Option<String>) -> Result<String> {
+    if state.phase != SessionPhase::Paused {
+        bail!("session is not paused (current phase: {:?})", state.phase);
+    }
+    let mut workflow_state = read_workflow_state(state)?;
+    if let Some(fb) = feedback {
+        workflow_state.pending_feedback.push(fb);
+    }
+    state.phase = SessionPhase::Implement;
+    write_workflow_state(state, &workflow_state)?;
+    let step_label = if let Some(step) = workflow_state.current_step() {
+        format!("step {}: {}", step.number, step.title)
+    } else {
+        "next step".to_string()
+    };
+    Ok(format!("resumed; advancing to {step_label}"))
+}
+
 pub fn mark_done(state: &mut SessionState, _agent: &str) -> Result<String> {
     match state.phase {
         SessionPhase::Done => Ok("session already complete".to_string()),
@@ -580,7 +613,11 @@ fn complete_step(
     }
 
     workflow_state.current_step_idx += 1;
-    state.phase = SessionPhase::Implement;
+    state.phase = if workflow_state.pause_after_step {
+        SessionPhase::Paused
+    } else {
+        SessionPhase::Implement
+    };
     Ok(())
 }
 

src/cli.rs

@@ -126,6 +126,12 @@ pub struct CreateArgs {
     pub turn_timeout_secs: u64,
     #[arg(long, default_value_t = 1200)]
     pub review_timeout_secs: u64,
+    #[arg(
+        long,
+        default_value_t = false,
+        help = "Pause for user feedback after each step is approved"
+    )]
+    pub pause_after_step: bool,
 }
 
 #[derive(Args, Debug)]
@@ -266,6 +272,16 @@ pub enum BuildSubcommand {
     Checkpoint(CheckpointArgs),
     #[command(about = "Submit a review verdict")]
     Review(ReviewArgs),
+    #[command(about = "Resume a paused session (advance to the next step)")]
+    Continue(ContinueArgs),
+}
+
+#[derive(Args, Debug)]
+pub struct ContinueArgs {
+    #[arg(long)]
+    pub session: String,
+    #[arg(long, help = "Optional feedback to pass to the implementer for the next step")]
+    pub feedback: Option<String>,
 }
 
 #[derive(Args, Debug)]

src/commands.rs

@@ -7,9 +7,9 @@ use serde_json::{Value, json};
 
 use crate::{
     cli::{
-        AgreeArgs, ChainArgs, ChallengeArgs, CheckpointArgs, CreateArgs, DoneArgs, FileIssueArgs,
-        JoinArgs, NextArgs, ReviewArgs, ReviewVerdictArg, SessionTypeArg, StatusArgs,
-        WorkflowActionArgs,
+        AgreeArgs, ChainArgs, ChallengeArgs, CheckpointArgs, ContinueArgs, CreateArgs, DoneArgs,
+        FileIssueArgs, JoinArgs, NextArgs, ReviewArgs, ReviewVerdictArg, SessionTypeArg,
+        StatusArgs, WorkflowActionArgs,
     },
     state::{
         AgentState, Config, SessionHandle, SessionPhase, SessionState, SessionType,
@@ -84,6 +84,7 @@ pub fn create_with_registry(args: &CreateArgs, registry: &WorkflowRegistry) -> R
                     Some(implement::initial_workflow_state(
                         args.implementer.clone(),
                         steps,
+                        args.pause_after_step,
                     )?),
                 )
             }
@@ -411,6 +412,17 @@ pub fn review_with_registry(args: &ReviewArgs, registry: &WorkflowRegistry) -> R
     Ok(())
 }
 
+pub fn continue_session_with_registry(args: &ContinueArgs) -> Result<()> {
+    let handle = SessionHandle::open(&args.session)?;
+    let mut state = handle.load_state()?;
+
+    let msg = implement::continue_session(&mut state, args.feedback.clone())?;
+
+    handle.save_state(&state)?;
+    println!("{msg}");
+    Ok(())
+}
+
 pub fn chain_with_registry(args: &ChainArgs, registry: &WorkflowRegistry) -> Result<()> {
     let plan_session_dir;
     loop {
@@ -454,6 +466,7 @@ pub fn chain_with_registry(args: &ChainArgs, registry: &WorkflowRegistry) -> Res
         max_rounds: 4,
         turn_timeout_secs: 300,
         review_timeout_secs: 1200,
+        pause_after_step: false,
     };
 
     let session_name = create_with_registry(&create_args, registry)?;

src/lib.rs

@@ -80,7 +80,12 @@ pub fn run_cli_with_registry(cli: Cli, registry: &WorkflowRegistry) -> Result<i3
                 BuildSubcommand::Checkpoint(inner) => {
                     commands::checkpoint_with_registry(&inner, registry)?
                 }
-                BuildSubcommand::Review(inner) => commands::review_with_registry(&inner, registry)?,
+                BuildSubcommand::Review(inner) => {
+                    commands::review_with_registry(&inner, registry)?
+                }
+                BuildSubcommand::Continue(inner) => {
+                    commands::continue_session_with_registry(&inner)?
+                }
             }
             Ok(0)
         }

src/workflow/builtin.rs

@@ -44,7 +44,7 @@ impl RunCommand for ImplementRunCommand {
     }
 
     fn usage(&self) -> &str {
-        "implement <todo-file> <role> [--reviewers N]"
+        "implement <todo-file> <role> [--reviewers N] [--pause-after-step]"
     }
 
     fn resolve(&self, args: &[String], workspace: &Path) -> Result<RunCommandResolution> {
@@ -59,6 +59,7 @@ impl RunCommand for ImplementRunCommand {
         let role = &args[1];
 
         let mut reviewers = 1u32;
+        let mut pause_after_step = false;
         let mut i = 2;
         while i < args.len() {
             if args[i] == "--reviewers" {
@@ -72,6 +73,11 @@ impl RunCommand for ImplementRunCommand {
                 i += 1;
                 continue;
             }
+            if args[i] == "--pause-after-step" {
+                pause_after_step = true;
+                i += 1;
+                continue;
+            }
             i += 1;
         }
 
@@ -109,6 +115,7 @@ impl RunCommand for ImplementRunCommand {
             max_rounds: 4,
             turn_timeout_secs: 300,
             review_timeout_secs: 1200,
+            pause_after_step,
         };
 
         Ok(RunCommandResolution::Session {
@@ -185,6 +192,7 @@ impl RunCommand for NegotiateRunCommand {
             max_rounds: 4,
             turn_timeout_secs: 300,
             review_timeout_secs: 1200,
+            pause_after_step: false,
         };
 
         Ok(RunCommandResolution::Session {
@@ -429,6 +437,15 @@ impl Workflow for BuildWorkflow {
             });
         }
 
+        if ctx.host.state.phase == SessionPhase::Paused {
+            return Ok(NextPollDispatch::Complete {
+                message: format!(
+                    "session paused for user feedback; run `rally build continue --session {}` to advance",
+                    ctx.host.state.name
+                ),
+            });
+        }
+
         Ok(NextPollDispatch::Wait {
             hint: implement::get_wait_hint(ctx.host.state, ctx.agent),
         })