fix(cli): make auto-compact non-agentic (#32)

Verified locally before merge: cargo check -p claurst --no-default-features (known claurst-tui::rustle warning only); git diff --check. Follow-up ensures failed/cancelled auto-compact does not reset context usage or show a false completion status. Co-authored-by: Nova <nova@openclaw.ai>

Author: BunsDev

src-rust/crates/cli/src/main.rs

@@ -1746,6 +1746,13 @@ async fn run_interactive(
     app.provider_registry = base_query_config.provider_registry.clone();
     app.refresh_context_window_size();
     app.auto_compact_enabled = live_config.auto_compact;
+    let compact_threshold = live_config.effective_compact_threshold();
+    let compact_threshold_pct = if compact_threshold <= 1.0 {
+        compact_threshold * 100.0
+    } else {
+        compact_threshold
+    };
+    app.auto_compact_threshold = compact_threshold_pct.clamp(0.0, 100.0).ceil() as u8;
     app.completion_toast_enabled = settings.completion_toast_enabled();
     app.bell_on_complete = settings.bell_on_complete;
 
@@ -3034,62 +3041,59 @@ async fn run_interactive(
             );
         }
 
-        // Auto-compact: when context usage hits 99% and no query is running,
-        // automatically submit a compact request.
-        if app.context_window_size > 0
+        // Auto-compact: when enabled and context usage reaches the configured
+        // threshold with no query running, summarize through the dedicated
+        // no-tools compaction path instead of starting an agentic turn.
+        if app.auto_compact_enabled
+            && app.context_window_size > 0
             && !app.is_streaming
             && current_query.is_none()
             && !app.auto_compact_running
         {
-            let used_pct = (app.context_used_tokens as f64 / app.context_window_size as f64 * 100.0) as u64;
-            if used_pct >= 99 {
+            let used_pct =
+                (app.context_used_tokens as f64 / app.context_window_size as f64 * 100.0) as u64;
+            if used_pct >= u64::from(app.auto_compact_threshold) {
                 app.auto_compact_running = true;
-                let msg_count = messages.len();
-                let compact_msg = format!(
-                    "[Auto-compact triggered ({} messages, {}% context used). \
-                     Provide a detailed summary of our conversation so far, \
-                     preserving all key technical details, decisions made, \
-                     file paths mentioned, and current task status.]",
-                    msg_count, used_pct
-                );
-                app.status_message = Some("Context 99% full — auto-compacting…".to_string());
-                let user_msg = claurst_core::types::Message::user(compact_msg);
-                messages.push(user_msg.clone());
-                app.push_message(user_msg);
-                session.messages = messages.clone();
-                session.updated_at = chrono::Utc::now();
+                app.status_message = Some(format!(
+                    "Context {}% full — auto-compacting…",
+                    used_pct
+                ));
 
-                // Dispatch the compact query immediately.
                 let ct = CancellationToken::new();
                 cancel = Some(ct.clone());
                 let msgs_arc = Arc::new(tokio::sync::Mutex::new(messages.clone()));
                 let msgs_arc_clone = msgs_arc.clone();
-                let tools_arc_clone = tools_arc.clone();
-                let ctx_clone = tool_ctx.clone();
-                let mut qcfg = base_query_config.clone();
-                qcfg.model = claurst_api::effective_model_for_config(&cmd_ctx.config, &model_registry);
-                qcfg.max_tokens = cmd_ctx.config.effective_max_tokens();
-                let tracker = cost_tracker.clone();
-                let tx = event_tx.clone();
+                let compact_model =
+                    claurst_api::effective_model_for_config(&cmd_ctx.config, &model_registry);
                 let client_clone = client.clone();
                 app.is_streaming = true;
 
                 let handle = tokio::spawn(async move {
-                    let mut msgs = msgs_arc_clone.lock().await.clone();
-                    let outcome = claurst_query::run_query_loop(
+                    if ct.is_cancelled() {
+                        return QueryOutcome::Cancelled;
+                    }
+
+                    let msgs = msgs_arc_clone.lock().await.clone();
+                    match claurst_query::compact_conversation(
                         client_clone.as_ref(),
-                        &mut msgs,
-                        tools_arc_clone.as_slice(),
-                        &ctx_clone,
-                        &qcfg,
-                        tracker,
-                        Some(tx),
-                        ct,
-                        None,
+                        &msgs,
+                        &compact_model,
                     )
-                    .await;
-                    *msgs_arc_clone.lock().await = msgs;
-                    outcome
+                    .await
+                    {
+                        Ok(compacted) => {
+                            let message = compacted
+                                .first()
+                                .cloned()
+                                .unwrap_or_else(|| claurst_core::types::Message::assistant(""));
+                            *msgs_arc_clone.lock().await = compacted;
+                            QueryOutcome::EndTurn {
+                                message,
+                                usage: claurst_core::types::UsageInfo::default(),
+                            }
+                        }
+                        Err(err) => QueryOutcome::Error(err),
+                    }
                 });
                 current_query = Some((handle, msgs_arc));
             }
@@ -3634,16 +3638,32 @@ async fn run_interactive(
         if task_finished {
             if let Some((handle, msgs_arc)) = current_query.take() {
                 // Get the outcome and handle errors
-                if let Ok(QueryOutcome::Error(err)) = handle.await {
-                    while app.notifications.current_is_error() {
-                        app.notifications.dismiss_current();
+                let query_outcome = handle.await;
+                match &query_outcome {
+                    Ok(QueryOutcome::Error(err)) => {
+                        while app.notifications.current_is_error() {
+                            app.notifications.dismiss_current();
+                        }
+                        app.notifications.push(
+                            claurst_tui::notifications::NotificationKind::Error,
+                            err.to_string(),
+                            None,
+                        );
                     }
-                    app.notifications.push(
-                        claurst_tui::notifications::NotificationKind::Error,
-                        err.to_string(),
-                        None,
-                    );
-                }
+                    Err(err) => {
+                        while app.notifications.current_is_error() {
+                            app.notifications.dismiss_current();
+                        }
+                        app.notifications.push(
+                            claurst_tui::notifications::NotificationKind::Error,
+                            format!("Query task failed: {}", err),
+                            None,
+                        );
+                    }
+                    _ => {}
+                };
+                let auto_compact_succeeded =
+                    matches!(query_outcome, Ok(QueryOutcome::EndTurn { .. }));
                 // Sync the updated conversation back to our local vector
                 messages = msgs_arc.lock().await.clone();
                 session.messages = messages.clone();
@@ -3661,9 +3681,16 @@ async fn run_interactive(
                 }
                 if app.auto_compact_running {
                     app.auto_compact_running = false;
-                    // After auto-compact the context was summarised — reset usage.
-                    app.context_used_tokens = 0;
-                    app.status_message = Some("Auto-compact complete.".to_string());
+                    if !auto_compact_succeeded {
+                        app.auto_compact_enabled = false;
+                        app.status_message = Some(
+                            "Auto-compact failed and was disabled for this session.".to_string(),
+                        );
+                    } else {
+                        // After auto-compact the context was summarised — reset usage.
+                        app.context_used_tokens = 0;
+                        app.status_message = Some("Auto-compact complete.".to_string());
+                    }
                 }
 
                 // Save session to JSONL (primary storage)