fix(cron): run jobs through conversation service (#546)

## Summary
- execute cron jobs through aionui-conversation instead of bypassing the
conversation turn path
- preserve assistant binding for existing-conversation cron jobs and
reject assistant changes in that mode
- persist cron trigger artifacts before assistant output and emit skill
suggestions per conversation

Refs iOfficeAI/AionUi#3472

## Test Plan
- cargo fmt --all -- --check
- cargo test -p aionui-cron
- cargo test -p aionui-conversation
- just push -u origin fix/cron-description-optional

Co-authored-by: zk <>

Author: kaizhou-lab

crates/aionui-app/assets/builtin-skills/auto-inject/cron/SKILL.md

@@ -26,7 +26,7 @@ Output `[CRON_LIST]` (nothing else in this message) and wait for the system resp
 - **Task already exists and user wants to change it** → Output `[CRON_UPDATE: <job-id>]` to modify in place.
 - **Task already exists and user wants something different** → Ask the user how to proceed.
 
-## Create: [CRON_CREATE]
+## Create: [ ]
 
 Output this format DIRECTLY (not in code blocks):
 

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

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

crates/aionui-app/tests/cron_e2e.rs

@@ -157,6 +157,17 @@ async fn cj1_create_cron_job() {
     assert_eq!(data["metadata"]["created_by"], "user");
 }
 
+#[tokio::test]
+async fn cj1b_create_job_allows_missing_task_description() {
+    let (mut app, services) = build_app().await;
+    let (token, csrf) = setup_and_login(&mut app, &services, "admin", "StrongP@ss1").await;
+
+    let data = create_job(&mut app, &token, &csrf, create_job_body("No Description")).await;
+
+    assert!(data.get("description").is_none());
+    assert_eq!(data["schedule"]["description"], "every minute");
+}
+
 // ── CJ-2: Create three schedule types ────────────────────────────────
 
 #[tokio::test]

crates/aionui-conversation/src/service.rs

@@ -344,6 +344,8 @@ pub struct ConversationAgentTurnRequest {
     pub content: String,
     pub files: Vec<String>,
     pub inject_skills: Vec<String>,
+    pub persist_user_message: bool,
+    pub user_message_hidden: bool,
     pub on_started: Option<ConversationAgentTurnStartedCallback>,
 }
 
@@ -367,6 +369,7 @@ pub struct ConversationAgentTurnOutcome {
     pub conversation_id: String,
     pub turn_id: String,
     pub status: ConversationAgentTurnStatus,
+    pub error_message: Option<String>,
     pub runtime: ConversationRuntimeSummary,
 }
 
@@ -2605,6 +2608,36 @@ impl ConversationService {
 
         let turn_id = Self::mint_turn_id();
         let turn_claim = self.runtime_state.try_claim_turn(&request.conversation_id, &turn_id)?;
+        if request.persist_user_message {
+            let user_msg_id = Self::mint_msg_id();
+            let user_msg = aionui_db::models::MessageRow {
+                id: user_msg_id.clone(),
+                conversation_id: request.conversation_id.clone(),
+                msg_id: Some(user_msg_id),
+                r#type: "text".into(),
+                content: serde_json::json!({ "content": request.content }).to_string(),
+                position: Some("right".into()),
+                status: Some("finish".into()),
+                hidden: request.user_message_hidden,
+                created_at: now_ms(),
+            };
+            if self
+                .runtime_persistence()
+                .allows(&request.conversation_id, RuntimeWriteKind::UserMessage)
+                && let Err(e) = self.conversation_repo.insert_message(&user_msg).await
+            {
+                warn!(
+                    msg_id = %user_msg.id,
+                    error = %ErrorChain(&e),
+                    "Failed to insert agent turn user message"
+                );
+                let mut turn_claim = turn_claim;
+                let was_deleting = turn_claim.release();
+                self.complete_released_turn(&request.conversation_id, &turn_id, was_deleting)
+                    .await;
+                return Err(e.into());
+            }
+        }
         if let Some(on_started) = request.on_started.as_ref() {
             on_started(ConversationAgentTurnStarted {
                 conversation_id: request.conversation_id.clone(),
@@ -2633,6 +2666,7 @@ impl ConversationService {
                     conversation_id: request.conversation_id.clone(),
                     turn_id,
                     status: ConversationAgentTurnStatus::Failed,
+                    error_message: Some(send_error_display_message(&send_error)),
                     runtime: self.runtime_summary_for(&request.conversation_id).await,
                 });
             }
@@ -2649,7 +2683,7 @@ impl ConversationService {
                     content: request.content,
                     files: request.files,
                     inject_skills: request.inject_skills,
-                    hidden: false,
+                    hidden: request.user_message_hidden,
                 },
                 build_options: build_opts,
                 stored_workspace,
@@ -2666,9 +2700,28 @@ impl ConversationService {
                 ConversationTurnStatus::Completed => ConversationAgentTurnStatus::Completed,
                 ConversationTurnStatus::Failed => ConversationAgentTurnStatus::Failed,
             },
+            error_message: result.error_message,
         })
     }
 
+    pub async fn latest_conversation_error_message(
+        &self,
+        conversation_id: &str,
+    ) -> Result<Option<String>, ConversationError> {
+        let page = self
+            .conversation_repo
+            .list_messages_page(
+                conversation_id,
+                &MessagePageParams {
+                    limit: 30,
+                    direction: MessagePageDirection::InitialLatest,
+                },
+            )
+            .await?;
+
+        Ok(page.items.iter().rev().find_map(error_message_from_message_row))
+    }
+
     pub(crate) async fn persist_and_broadcast_send_failure_tip(
         &self,
         conversation_id: &str,
@@ -2867,6 +2920,49 @@ impl ConversationService {
     }
 }
 
+fn send_error_display_message(error: &AgentSendError) -> String {
+    error
+        .stream_error()
+        .detail
+        .as_deref()
+        .filter(|detail| !detail.trim().is_empty())
+        .unwrap_or(error.stream_error().message.as_str())
+        .to_owned()
+}
+
+fn error_message_from_message_row(row: &MessageRow) -> Option<String> {
+    if row.r#type != "tips" && row.status.as_deref() != Some("error") {
+        return None;
+    }
+
+    let content: serde_json::Value = serde_json::from_str(&row.content).ok()?;
+    let is_error_tip = content.get("type").and_then(serde_json::Value::as_str) == Some("error")
+        || row.status.as_deref() == Some("error");
+    if !is_error_tip {
+        return None;
+    }
+
+    [
+        content.pointer("/error/detail"),
+        content.pointer("/details/detail"),
+        content.get("details"),
+        content.get("content"),
+        content.pointer("/error/message"),
+    ]
+    .into_iter()
+    .flatten()
+    .filter_map(non_empty_json_string)
+    .find(|message| message != "cron conversation turn failed")
+}
+
+fn non_empty_json_string(value: &serde_json::Value) -> Option<String> {
+    value
+        .as_str()
+        .map(str::trim)
+        .filter(|value| !value.is_empty())
+        .map(str::to_owned)
+}
+
 // ── Internal Helpers ────────────────────────────────────────────────
 
 pub(crate) fn agent_error_top_level_code(error: &AgentError) -> &'static str {

crates/aionui-conversation/src/service_test.rs

@@ -47,9 +47,9 @@ use aionui_realtime::EventBroadcaster;
 use serde_json::json;
 use tokio::sync::{Notify, broadcast};
 
-use crate::ConversationError;
 use crate::service::ConversationService;
 use crate::skill_resolver::{FixedSkillResolver, ResolvedAgentSkill, SkillResolver};
+use crate::{ConversationAgentTurnRequest, ConversationAgentTurnStatus, ConversationError};
 
 #[path = "service_test/acp_error_recovery_test.rs"]
 mod acp_error_recovery_test;
@@ -3763,6 +3763,81 @@ async fn send_message_persists_error_tip_when_agent_build_fails() {
     assert_eq!(error_tip_event.data["turn_id"], response.turn_id);
 }
 
+#[tokio::test]
+async fn run_agent_turn_returns_error_message_when_agent_build_fails() {
+    let task_mgr: Arc<dyn IWorkerTaskManager> =
+        Arc::new(FailingBuildTaskManager::new("ACP init failed: config file is invalid"));
+    let repo = Arc::new(MockRepo::new());
+    let broadcaster = Arc::new(MockBroadcaster::new());
+    let service = ConversationService::new(
+        std::env::temp_dir(),
+        broadcaster,
+        Arc::new(FixedSkillResolver { names: vec![] }),
+        task_mgr,
+        repo,
+        Arc::new(StubAgentMetadataRepo),
+        Arc::new(StubAcpSessionRepo::default()),
+    );
+
+    let conv = service.create("user_1", make_create_req()).await.unwrap();
+    let outcome = service
+        .run_agent_turn(ConversationAgentTurnRequest {
+            user_id: "user_1".into(),
+            conversation_id: conv.id,
+            content: "run scheduled task".into(),
+            files: Vec::new(),
+            inject_skills: Vec::new(),
+            persist_user_message: true,
+            user_message_hidden: true,
+            on_started: None,
+        })
+        .await
+        .unwrap();
+
+    assert_eq!(outcome.status, ConversationAgentTurnStatus::Failed);
+    assert_eq!(
+        outcome.error_message.as_deref(),
+        Some("ACP init failed: config file is invalid")
+    );
+}
+
+#[tokio::test]
+async fn latest_conversation_error_message_prefers_error_detail() {
+    let (svc, _broadcaster, repo, _task_mgr) = make_service();
+    let conv = svc.create("user_1", make_create_req()).await.unwrap();
+    repo.insert_message(&MessageRow {
+        id: "msg_error".into(),
+        conversation_id: conv.id.clone(),
+        msg_id: None,
+        r#type: "tips".into(),
+        content: serde_json::json!({
+            "content": "Current agent failed",
+            "type": "error",
+            "details": {
+                "detail": "Cannot resume Claude session with Codex assistant"
+            },
+            "error": {
+                "message": "Current agent failed",
+                "detail": "Codex cannot resume a conversation created by Claude"
+            }
+        })
+        .to_string(),
+        position: Some("center".into()),
+        status: Some("error".into()),
+        hidden: false,
+        created_at: 10,
+    })
+    .await
+    .unwrap();
+
+    let message = svc.latest_conversation_error_message(&conv.id).await.unwrap();
+
+    assert_eq!(
+        message.as_deref(),
+        Some("Codex cannot resume a conversation created by Claude")
+    );
+}
+
 #[tokio::test]
 async fn send_message_persists_openclaw_gateway_unreachable_tip_when_turn_build_fails() {
     let (svc, broadcaster, repo, _default_task_mgr) = make_service();

crates/aionui-conversation/src/turn_orchestrator.rs

@@ -43,6 +43,7 @@ pub(crate) enum ConversationTurnStatus {
 
 pub(crate) struct ConversationTurnResult {
     pub status: ConversationTurnStatus,
+    pub error_message: Option<String>,
 }
 
 pub(crate) struct ConversationTurnOrchestrator {
@@ -123,7 +124,7 @@ impl ConversationTurnOrchestrator {
                     error = %ErrorChain(&err),
                     "Agent task build failed"
                 );
-                let failure_message = err.to_string();
+                let failure_message = send_error_display_message(&send_error);
                 record_agent_session_failure(
                     &self.service,
                     availability_agent_id.as_deref(),
@@ -141,6 +142,7 @@ impl ConversationTurnOrchestrator {
                     .await;
                 return Err(ConversationTurnResult {
                     status: ConversationTurnStatus::Failed,
+                    error_message: Some(failure_message),
                 });
             }
         };
@@ -151,6 +153,7 @@ impl ConversationTurnOrchestrator {
             .await
         {
             let top_level_code = err.error_code();
+            let failure_message = err.to_string();
             let send_error = AgentSendError::from_agent_error(err.to_agent_error());
             error!(
                 conversation_id = %input.conv_id,
@@ -169,6 +172,7 @@ impl ConversationTurnOrchestrator {
                 .await;
             return Err(ConversationTurnResult {
                 status: ConversationTurnStatus::Failed,
+                error_message: Some(failure_message),
             });
         }
 
@@ -220,7 +224,7 @@ impl ConversationTurnOrchestrator {
 
             tokio::spawn(async move {
                 if let Err(e) = send_agent.send_message(current_send).await {
-                    let failure_message = availability_failure_message(&e);
+                    let failure_message = send_error_display_message(&e);
                     record_agent_session_failure(
                         &feedback_service,
                         feedback_agent_id.as_deref(),
@@ -317,6 +321,7 @@ impl ConversationTurnOrchestrator {
         };
         let mut replayed = false;
         let mut replay_started_at = None;
+        let mut final_error_message;
 
         info!(conversation_id = %conv_id, turn_id = %turn_id, "conversation turn orchestrator started");
 
@@ -339,12 +344,14 @@ impl ConversationTurnOrchestrator {
             {
                 Ok(result) => result,
                 Err(result) => {
+                    final_error_message = result.error_message;
                     break result.status == ConversationTurnStatus::Failed;
                 }
             };
 
             let lifecycle = runtime_state.lifecycle_for(&conv_id);
             if !attempt_result.outcome.terminal.is_error() {
+                final_error_message = None;
                 if replayed {
                     info!(
                         conversation_id = %conv_id,
@@ -358,6 +365,7 @@ impl ConversationTurnOrchestrator {
                 }
                 break false;
             }
+            final_error_message = turn_attempt_error_message(&attempt_result.summary);
             if replayed {
                 warn!(
                     conversation_id = %conv_id,
@@ -447,6 +455,7 @@ impl ConversationTurnOrchestrator {
             } else {
                 ConversationTurnStatus::Completed
             },
+            error_message: if final_failed { final_error_message } else { None },
         }
     }
 }
@@ -463,14 +472,25 @@ fn availability_agent_id(options: &BuildTaskOptions) -> Option<String> {
     }
 }
 
-fn availability_failure_message(error: &AgentSendError) -> String {
+fn send_error_display_message(error: &AgentSendError) -> String {
     error
         .stream_error()
         .detail
         .clone()
         .unwrap_or_else(|| error.stream_error().message.clone())
 }
 
+fn turn_attempt_error_message(summary: &TurnAttemptSummary) -> Option<String> {
+    summary.terminal_error.as_ref().map(|error| {
+        error
+            .detail
+            .as_deref()
+            .filter(|detail| !detail.trim().is_empty())
+            .unwrap_or(error.message.as_str())
+            .to_owned()
+    })
+}
+
 async fn record_agent_session_failure(
     service: &ConversationService,
     agent_id: Option<&str>,