Allow negotiate workflow with 2 agents

src/commands.rs

@@ -94,10 +94,10 @@ pub fn create_with_registry(args: &CreateArgs, registry: &WorkflowRegistry) -> R
                     .ok_or_else(|| anyhow::anyhow!("--workflow is required for create workflow"))?;
                 let _ = registry.resolve_str(&workflow_id)?;
                 if workflow_id == workflow::builtin::NEGOTIATE_WORKFLOW_ID
-                    && expected_agents < 3
+                    && expected_agents < 2
                 {
                     bail!(
-                        "workflow '{}' requires --agents >= 3 (got {})",
+                        "workflow '{}' requires --agents >= 2 (got {})",
                         workflow_id,
                         expected_agents
                     );

src/workflow/builtin.rs

@@ -31,6 +31,7 @@ pub struct ConsultWorkflow;
 pub struct ComposedNegotiateWorkflow;
 pub struct HelloWorkflow;
 pub struct ImplementRunCommand;
+pub struct NegotiateRunCommand;
 pub struct HelloRunCommand;
 
 impl RunCommand for ImplementRunCommand {
@@ -118,6 +119,82 @@ impl RunCommand for ImplementRunCommand {
     }
 }
 
+impl RunCommand for NegotiateRunCommand {
+    fn name(&self) -> &str {
+        "negotiate"
+    }
+
+    fn description(&self) -> &str {
+        "Create or join a negotiate session for multi-agent planning"
+    }
+
+    fn usage(&self) -> &str {
+        "negotiate <topic> <role> [--agents N]"
+    }
+
+    fn resolve(&self, args: &[String], _workspace: &Path) -> Result<RunCommandResolution> {
+        if args.len() < 2 {
+            bail!(
+                "usage: /rally {}\n\nExample: /rally negotiate \"auth design\" agent-alpha",
+                self.usage()
+            );
+        }
+
+        let topic = &args[0];
+        let role = &args[1];
+
+        let mut agents = 2u32;
+        let mut i = 2;
+        while i < args.len() {
+            if args[i] == "--agents" {
+                i += 1;
+                if i >= args.len() {
+                    bail!("--agents requires a number argument");
+                }
+                agents = args[i]
+                    .parse()
+                    .map_err(|_| anyhow!("--agents must be a number, got '{}'", args[i]))?;
+                i += 1;
+                continue;
+            }
+            i += 1;
+        }
+
+        let slug: String = topic
+            .to_ascii_lowercase()
+            .chars()
+            .map(|c| if c.is_alphanumeric() { c } else { '-' })
+            .collect::<String>()
+            .split('-')
+            .filter(|s| !s.is_empty())
+            .collect::<Vec<_>>()
+            .join("-");
+        let session_name = format!("negotiate-{slug}");
+        let agent_name = normalize_agent_selector(role);
+
+        let create_args = CreateArgs {
+            session_type: SessionTypeArg::Workflow,
+            name: session_name.clone(),
+            agents: Some(agents),
+            reviewers: None,
+            todo: None,
+            workspace: None,
+            workflow: Some("negotiate".to_string()),
+            implementer: String::new(),
+            topic: Some(topic.clone()),
+            max_rounds: 4,
+            turn_timeout_secs: 300,
+            review_timeout_secs: 1200,
+        };
+
+        Ok(RunCommandResolution::Session {
+            session_name,
+            agent_name,
+            create_args,
+        })
+    }
+}
+
 impl RunCommand for HelloRunCommand {
     fn name(&self) -> &str {
         "hello"
@@ -253,6 +330,11 @@ impl Workflow for ComposedNegotiateWorkflow {
         &["file-issue", "position", "challenge", "agree"]
     }
 
+    fn run_command(&self) -> Option<&dyn RunCommand> {
+        static COMMAND: NegotiateRunCommand = NegotiateRunCommand;
+        Some(&COMMAND)
+    }
+
     fn on_create(&self, ctx: &mut super::CreateContext<'_>) -> Result<super::CreateDispatch> {
         ctx.host.state.workflow_state = Some(plan::initial_workflow_state()?);
         for p in [
@@ -738,6 +820,57 @@ mod tests {
         assert!(!cmd.usage().is_empty());
     }
 
+    #[test]
+    fn negotiate_run_command_resolve_valid_args() {
+        let workspace = temp_workspace("rally-negotiate-cmd-valid");
+        let cmd = NegotiateRunCommand;
+        let args = vec!["auth design".to_string(), "agent-alpha".to_string()];
+        let (session_name, agent_name, create_args) =
+            unwrap_session(cmd.resolve(&args, &workspace).expect("resolve"));
+        assert_eq!(session_name, "negotiate-auth-design");
+        assert_eq!(agent_name, "agent-alpha");
+        assert_eq!(create_args.agents, Some(2));
+        assert_eq!(create_args.workflow.as_deref(), Some("negotiate"));
+        assert_eq!(create_args.topic.as_deref(), Some("auth design"));
+    }
+
+    #[test]
+    fn negotiate_run_command_resolve_custom_agents() {
+        let workspace = temp_workspace("rally-negotiate-cmd-agents");
+        let cmd = NegotiateRunCommand;
+        let args = vec![
+            "my topic".to_string(),
+            "agent-beta".to_string(),
+            "--agents".to_string(),
+            "4".to_string(),
+        ];
+        let (_, _, create_args) =
+            unwrap_session(cmd.resolve(&args, &workspace).expect("resolve"));
+        assert_eq!(create_args.agents, Some(4));
+    }
+
+    #[test]
+    fn negotiate_run_command_resolve_missing_args() {
+        let workspace = temp_workspace("rally-negotiate-cmd-missing");
+        let cmd = NegotiateRunCommand;
+        let err = cmd
+            .resolve(&[], &workspace)
+            .expect_err("should fail with missing args");
+        assert!(err.to_string().contains("usage:"));
+
+        let err = cmd
+            .resolve(&["only-topic".to_string()], &workspace)
+            .expect_err("should fail with one arg");
+        assert!(err.to_string().contains("usage:"));
+    }
+
+    #[test]
+    fn negotiate_workflow_exposes_run_command() {
+        let workflow = ComposedNegotiateWorkflow;
+        let cmd = workflow.run_command().expect("should have run command");
+        assert_eq!(cmd.name(), "negotiate");
+    }
+
     #[test]
     fn plan_workflow_has_no_run_command() {
         let workflow = PlanWorkflow;