fix(cron): enforce full-auto mode for scheduled tasks (#576)

## Summary
- preserve cron jobs when related conversations are deleted and create
replacement conversations for existing-mode jobs when needed
- enforce scheduled task runtime mode through the agent runtime before
dispatch, using assistant/agent metadata full-auto mode values instead
of hardcoded yolo ids
- keep existing-mode replacement conversations eligible for cron skill
editing and return the active conversation when run-now is clicked while
it is already running

## Tests
- cargo fmt --all -- --check
- git diff --check
- cargo nextest run -p aionui-cron
- cargo nextest run -p aionui-conversation
run_agent_turn_applies_required_runtime_mode_after_stream_subscription
save_acp_runtime_mode_updates_runtime_mode_config_selection
- cargo check -p aionui-app
- just push -u origin fix/cron-skill-yolo-mode

Co-authored-by: zk <>

Author: kaizhou-lab

crates/aionui-app/src/router/team_conversation_adapters.rs

@@ -80,6 +80,7 @@ impl AgentTurnExecutionPort for TeamConversationAdapters {
                     content: request.content.clone(),
                     files: request.files.clone(),
                     inject_skills: Vec::new(),
+                    required_runtime_mode: None,
                     persist_user_message: false,
                     user_message_hidden: false,
                     on_started: on_started.clone(),

crates/aionui-conversation/src/service.rs

@@ -334,6 +334,7 @@ pub struct ConversationAgentTurnRequest {
     pub content: String,
     pub files: Vec<String>,
     pub inject_skills: Vec<String>,
+    pub required_runtime_mode: Option<String>,
     pub persist_user_message: bool,
     pub user_message_hidden: bool,
     pub on_started: Option<ConversationAgentTurnStartedCallback>,
@@ -1997,8 +1998,21 @@ impl ConversationService {
     }
 
     pub async fn save_acp_runtime_mode(&self, conversation_id: &str, mode: &str) -> Result<(), ConversationError> {
+        let runtime_state = self
+            .acp_session_repo
+            .load_runtime_state(conversation_id)
+            .await
+            .map_err(|e| ConversationError::internal(format!("Failed to load runtime mode state: {e}")))?;
+        let mut config_selections = runtime_state
+            .and_then(|state| state.config_selections_json)
+            .and_then(|raw| serde_json::from_str::<HashMap<String, String>>(&raw).ok())
+            .unwrap_or_default();
+        config_selections.insert("mode".to_owned(), mode.to_owned());
+        let config_selections_json = serde_json::to_string(&config_selections)
+            .map_err(|e| ConversationError::internal(format!("Failed to serialize runtime mode selection: {e}")))?;
         let params = SaveRuntimeStateParams {
             current_mode_id: Some(Some(mode)),
+            config_selections_json: Some(Some(config_selections_json.as_str())),
             ..Default::default()
         };
         self.acp_session_repo
@@ -2670,6 +2684,7 @@ impl ConversationService {
             user_id: user_id.to_owned(),
             conversation: row,
             request: req,
+            required_runtime_mode: None,
             build_options: build_opts,
             stored_workspace,
             turn_id: turn_id.clone(),
@@ -2793,6 +2808,7 @@ impl ConversationService {
                     inject_skills: request.inject_skills,
                     hidden: request.user_message_hidden,
                 },
+                required_runtime_mode: request.required_runtime_mode,
                 build_options: build_opts,
                 stored_workspace,
                 turn_id: turn_id.clone(),

crates/aionui-conversation/src/service_test.rs

@@ -862,13 +862,15 @@ struct RuntimeStateSaveCall {
     conversation_id: String,
     current_mode_id: Option<Option<String>>,
     current_model_id: Option<Option<String>>,
+    config_selections_json: Option<Option<String>>,
 }
 
 #[derive(Default)]
 struct StubAcpSessionRepo {
     create_calls: Mutex<Vec<CreateAcpSessionCall>>,
     runtime_state_saves: Mutex<Vec<RuntimeStateSaveCall>>,
     session_id: Mutex<Option<String>>,
+    runtime_state: Mutex<Option<PersistedSessionState>>,
 }
 
 impl StubAcpSessionRepo {
@@ -881,6 +883,16 @@ impl StubAcpSessionRepo {
             create_calls: Mutex::new(Vec::new()),
             runtime_state_saves: Mutex::new(Vec::new()),
             session_id: Mutex::new(Some(session_id.into())),
+            runtime_state: Mutex::new(None),
+        }
+    }
+
+    fn with_runtime_state(state: PersistedSessionState) -> Self {
+        Self {
+            create_calls: Mutex::new(Vec::new()),
+            runtime_state_saves: Mutex::new(Vec::new()),
+            session_id: Mutex::new(None),
+            runtime_state: Mutex::new(Some(state)),
         }
     }
 
@@ -941,10 +953,12 @@ impl IAcpSessionRepository for StubAcpSessionRepo {
         Ok(false)
     }
     async fn load_runtime_state(&self, _conversation_id: &str) -> Result<Option<PersistedSessionState>, DbError> {
-        Ok(Some(PersistedSessionState {
-            current_model_id: Some("deepseek-v4-pro".to_owned()),
-            ..Default::default()
-        }))
+        Ok(Some(self.runtime_state.lock().unwrap().clone().unwrap_or(
+            PersistedSessionState {
+                current_model_id: Some("deepseek-v4-pro".to_owned()),
+                ..Default::default()
+            },
+        )))
     }
     async fn save_runtime_state(
         &self,
@@ -955,6 +969,7 @@ impl IAcpSessionRepository for StubAcpSessionRepo {
             conversation_id: conversation_id.to_owned(),
             current_mode_id: params.current_mode_id.map(|outer| outer.map(ToOwned::to_owned)),
             current_model_id: params.current_model_id.map(|outer| outer.map(ToOwned::to_owned)),
+            config_selections_json: params.config_selections_json.map(|outer| outer.map(ToOwned::to_owned)),
         });
         Ok(true)
     }
@@ -2528,6 +2543,11 @@ impl MockAgent {
         self
     }
 
+    fn with_mode(self, mode: &str) -> Self {
+        *self.mode.lock().unwrap() = mode.to_owned();
+        self
+    }
+
     fn with_set_config_option_response(self, response: SetConfigOptionResponse) -> Self {
         *self.set_config_option_response.lock().unwrap() = Some(response);
         self
@@ -2634,16 +2654,30 @@ impl IMockAgent for MockAgent {
             .lock()
             .unwrap()
             .push((option_id.to_owned(), value.to_owned()));
+        if option_id == "mode" {
+            *self.mode.lock().unwrap() = value.to_owned();
+        }
         if let Some(error) = self.set_config_option_error.lock().unwrap().take() {
             return Err(error);
         }
         if let Some(response) = self.set_config_option_response.lock().unwrap().clone() {
+            if let Some(config_options) = response.config_options.as_ref() {
+                let _ = self.event_tx.send(AgentStreamEvent::AcpConfigOption(json!({
+                    "config_options": config_options,
+                })));
+            }
             return Ok(response);
         }
-        Ok(SetConfigOptionResponse {
+        let response = SetConfigOptionResponse {
             confirmation: ConfigOptionConfirmation::Observed,
             config_options: Some(self.config_options.lock().unwrap().clone()),
-        })
+        };
+        if let Some(config_options) = response.config_options.as_ref() {
+            let _ = self.event_tx.send(AgentStreamEvent::AcpConfigOption(json!({
+                "config_options": config_options,
+            })));
+        }
+        Ok(response)
     }
 }
 
@@ -3408,6 +3442,7 @@ async fn run_agent_turn_injects_conversation_runtime_context() {
             content: "run scheduled task".into(),
             files: Vec::new(),
             inject_skills: Vec::new(),
+            required_runtime_mode: None,
             persist_user_message: true,
             user_message_hidden: true,
             on_started: None,
@@ -3583,6 +3618,90 @@ async fn set_config_option_returns_observed_confirmation() {
     );
 }
 
+#[tokio::test]
+async fn save_acp_runtime_mode_updates_runtime_mode_config_selection() {
+    let acp_repo = Arc::new(StubAcpSessionRepo::with_runtime_state(PersistedSessionState {
+        current_mode_id: Some("read-only".to_owned()),
+        current_model_id: Some("gpt-5.3-codex".to_owned()),
+        config_selections_json: Some(
+            serde_json::json!({
+                "mode": "read-only",
+                "model": "gpt-5.3-codex",
+                "reasoning_effort": "low"
+            })
+            .to_string(),
+        ),
+        context_usage_json: None,
+    }));
+    let (svc, _, _, _) = make_service_with_resolver_and_acp_session_repo(
+        Arc::new(FixedSkillResolver { names: vec![] }),
+        acp_repo.clone(),
+    );
+    svc.save_acp_runtime_mode("conv_1", "full-access").await.unwrap();
+
+    let saves = acp_repo.runtime_state_saves();
+    assert_eq!(saves.len(), 1);
+    assert_eq!(saves[0].current_mode_id, Some(Some("full-access".to_owned())));
+    let selections: serde_json::Value =
+        serde_json::from_str(saves[0].config_selections_json.as_ref().unwrap().as_ref().unwrap()).unwrap();
+    assert_eq!(selections["mode"], "full-access");
+    assert_eq!(selections["model"], "gpt-5.3-codex");
+    assert_eq!(selections["reasoning_effort"], "low");
+}
+
+#[tokio::test]
+async fn run_agent_turn_applies_required_runtime_mode_after_stream_subscription() {
+    let task_mgr = Arc::new(MockTaskManager::new());
+    let (svc, broadcaster, _repo) = make_service_with_mock_task_manager(task_mgr.clone());
+    let conv = svc.create("user_1", make_create_req()).await.unwrap();
+    broadcaster.take_events();
+
+    let agent = Arc::new(
+        MockAgent::new(&conv.id)
+            .with_mode("yolo")
+            .with_config_options(vec![AcpConfigOptionDto {
+                id: "mode".to_owned(),
+                name: Some("Mode".to_owned()),
+                label: None,
+                description: None,
+                category: Some("mode".to_owned()),
+                option_type: "select".to_owned(),
+                current_value: Some("yolo".to_owned()),
+                options: Vec::new(),
+            }]),
+    );
+    task_mgr.insert_agent(&conv.id, AgentInstance::Mock(agent.clone()));
+
+    let outcome = svc
+        .run_agent_turn(ConversationAgentTurnRequest {
+            user_id: "user_1".to_owned(),
+            conversation_id: conv.id.clone(),
+            content: "run scheduled task".to_owned(),
+            files: Vec::new(),
+            inject_skills: Vec::new(),
+            required_runtime_mode: Some("yolo".to_owned()),
+            persist_user_message: true,
+            user_message_hidden: true,
+            on_started: None,
+        })
+        .await
+        .unwrap();
+
+    assert_eq!(outcome.status, ConversationAgentTurnStatus::Completed);
+    assert_eq!(
+        agent.set_config_option_calls.lock().unwrap().as_slice(),
+        &[("mode".to_owned(), "yolo".to_owned())]
+    );
+    let events = broadcaster.take_events();
+    let config_event = events
+        .iter()
+        .find(|event| event.name == "message.stream" && event.data["type"] == "acp_config_option")
+        .expect("runtime mode switch should broadcast config option snapshot");
+    assert_eq!(config_event.data["conversation_id"], conv.id);
+    assert_eq!(config_event.data["data"]["config_options"][0]["id"], "mode");
+    assert_eq!(config_event.data["data"]["config_options"][0]["current_value"], "yolo");
+}
+
 #[tokio::test]
 async fn set_config_option_evicts_task_when_acp_protocol_is_not_connected() {
     let task_mgr = Arc::new(MockTaskManager::new());
@@ -4304,6 +4423,7 @@ async fn run_agent_turn_returns_error_message_when_agent_build_fails() {
             content: "run scheduled task".into(),
             files: Vec::new(),
             inject_skills: Vec::new(),
+            required_runtime_mode: None,
             persist_user_message: true,
             user_message_hidden: true,
             on_started: None,

crates/aionui-conversation/src/service_test/acp_error_recovery_test.rs

@@ -102,6 +102,7 @@ async fn send_message_clears_persisted_acp_model_after_model_not_found() {
             conversation_id: conv.id.clone(),
             current_mode_id: None,
             current_model_id: Some(None),
+            config_selections_json: None,
         }]
     );
 

crates/aionui-conversation/src/turn_orchestrator.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use aionui_ai_agent::types::{BuildTaskOptions, SendMessageData};
-use aionui_ai_agent::{AgentSendError, AgentSessionKind, IWorkerTaskManager};
+use aionui_ai_agent::{AgentError, AgentInstance, AgentSendError, AgentSessionKind, IWorkerTaskManager};
 use aionui_common::{AgentType, ConversationStatus, ErrorChain, now_ms};
 use aionui_db::models::ConversationRow;
 use tokio::sync::oneshot;
@@ -29,6 +29,7 @@ pub(crate) struct TurnStartInput {
     pub user_id: String,
     pub conversation: ConversationRow,
     pub request: SendMessageRequest,
+    pub required_runtime_mode: Option<String>,
     pub build_options: BuildTaskOptions,
     pub stored_workspace: String,
     pub turn_id: String,
@@ -60,6 +61,7 @@ struct TurnAttemptInput {
     send: SendMessageData,
     msg_id: String,
     allowed_skill_names: Vec<String>,
+    required_runtime_mode: Option<String>,
     continuation_count: usize,
     defer_clean_terminal_errors: bool,
 }
@@ -214,6 +216,47 @@ impl ConversationTurnOrchestrator {
             .with_defer_clean_terminal_errors(defer_clean_terminal_errors);
 
             let rx = agent.subscribe();
+            if let Some(mode) = input
+                .required_runtime_mode
+                .as_deref()
+                .map(str::trim)
+                .filter(|mode| !mode.is_empty())
+            {
+                match apply_required_runtime_mode(&agent, mode).await {
+                    Ok(()) => {
+                        info!(
+                            conversation_id = %input.conv_id,
+                            turn_id = %input.turn_id,
+                            mode,
+                            "Confirmed required runtime mode before agent turn"
+                        );
+                    }
+                    Err(err) => {
+                        let top_level_code = agent_error_top_level_code(&err);
+                        let failure_message = err.to_string();
+                        let send_error = AgentSendError::from_agent_error(err);
+                        error!(
+                            conversation_id = %input.conv_id,
+                            turn_id = %input.turn_id,
+                            mode,
+                            error = %failure_message,
+                            "Failed to apply required runtime mode before agent turn"
+                        );
+                        self.service
+                            .persist_and_broadcast_send_failure_tip(
+                                &input.conv_id,
+                                &input.turn_id,
+                                &send_error,
+                                Some(top_level_code),
+                            )
+                            .await;
+                        return Err(ConversationTurnResult {
+                            status: ConversationTurnStatus::Failed,
+                            error_message: Some(failure_message),
+                        });
+                    }
+                }
+            }
             let send_agent = agent.clone();
             let conv_id_send = input.conv_id.clone();
             let turn_id_for_send = input.turn_id.clone();
@@ -336,6 +379,7 @@ impl ConversationTurnOrchestrator {
                     send: initial_send.clone(),
                     msg_id: first_turn_msg_id.clone(),
                     allowed_skill_names: allowed_skill_names.clone(),
+                    required_runtime_mode: input.required_runtime_mode.clone(),
                     continuation_count: 0,
                     defer_clean_terminal_errors: !replayed,
                 })
@@ -471,6 +515,11 @@ fn availability_agent_id(options: &BuildTaskOptions) -> Option<String> {
     }
 }
 
+async fn apply_required_runtime_mode(agent: &AgentInstance, mode: &str) -> Result<(), AgentError> {
+    agent.set_config_option("mode", mode).await?;
+    Ok(())
+}
+
 fn send_error_display_message(error: &AgentSendError) -> String {
     error
         .stream_error()

crates/aionui-conversation/tests/stream_relay_tool_call.rs

@@ -322,6 +322,7 @@ async fn run_agent_turn_with_empty_call_id_tool_call_is_not_persisted() {
             content: "run glob".into(),
             files: Vec::new(),
             inject_skills: Vec::new(),
+            required_runtime_mode: None,
             persist_user_message: false,
             user_message_hidden: false,
             on_started: None,