fix: eliminate silent failures — add observability to critical data paths

FSM transitions (loop_driver.rs):
- Replace 9x `let _ = fsm.transition()` with `if let Err(e) = ... { debug!() }`
- State machine violations are now visible in traces instead of silently ignored
- Critical for debugging agent loops that stall or produce incorrect results

Desktop UI (chat.rs):
- Permission approval/denial: try_send failure now logs error!()
  (security-critical: dropped permission decisions could hang executor)
- Chat message send: try_send failure logs error!() and resets streaming state
  (prevents ghost "sending" state when message is actually dropped)
- Cancellation: try_send failure now logs warn!()

API permission handler (chat.rs):
- Permission decision forwarding now logs error!() when channel is closed
  (was silently dropping approve/deny decisions)

Event bus (bus.rs):
- Broadcast with zero subscribers now logs at trace level
  (was completely silent)

Strategy/Memory persistence (loop_driver.rs):
- Serialization failures now log warn!() before converting to None
  (was silently discarding strategy learning and memory data)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: osvalois

crates/halcon-agent-core/src/loop_driver.rs

@@ -276,7 +276,7 @@ pub async fn run_gdem_loop(user_message: &str, mut ctx: GdemContext) -> Result<G
 
         // ── Transition to Executing ────────────────────────────────────────
         if !matches!(fsm.state(), AgentState::Executing) {
-            let _ = fsm.transition(AgentState::Executing);
+            if let Err(e) = fsm.transition(AgentState::Executing) { tracing::debug!(error = %e, "FSM transition to Executing failed"); }
         }
 
         // ── Get current plan step ─────────────────────────────────────────
@@ -369,7 +369,7 @@ pub async fn run_gdem_loop(user_message: &str, mut ctx: GdemContext) -> Result<G
         }
 
         // ── L4: Verify ────────────────────────────────────────────────────
-        let _ = fsm.transition(AgentState::Verifying);
+        if let Err(e) = fsm.transition(AgentState::Verifying) { tracing::debug!(error = %e, "FSM transition to Verifying failed"); }
         let verifier_decision = verifier.verify(&evidence);
         let post_confidence = verifier_decision.confidence().unwrap_or(pre_confidence);
 
@@ -387,7 +387,7 @@ pub async fn run_gdem_loop(user_message: &str, mut ctx: GdemContext) -> Result<G
                 confidence = post_confidence,
                 "Goal ACHIEVED — exiting loop"
             );
-            let _ = fsm.transition(AgentState::Converged);
+            if let Err(e) = fsm.transition(AgentState::Converged) { tracing::debug!(error = %e, "FSM transition to Converged failed"); }
             break 'agent;
         }
 
@@ -406,23 +406,23 @@ pub async fn run_gdem_loop(user_message: &str, mut ctx: GdemContext) -> Result<G
 
         match critic_signal {
             CriticSignal::Continue => {
-                let _ = fsm.transition(AgentState::Executing);
+                if let Err(e) = fsm.transition(AgentState::Executing) { tracing::debug!(error = %e, "FSM transition to Executing failed"); }
             }
             CriticSignal::InjectHint { hint, .. } => {
                 hint_injection = Some(hint);
-                let _ = fsm.transition(AgentState::Executing);
+                if let Err(e) = fsm.transition(AgentState::Executing) { tracing::debug!(error = %e, "FSM transition to Executing failed"); }
             }
             CriticSignal::Replan { reason, .. } => {
                 warn!(round = round, reason = %reason, "Critic triggering replan");
-                let _ = fsm.transition(AgentState::Replanning);
+                if let Err(e) = fsm.transition(AgentState::Replanning) { tracing::debug!(error = %e, "FSM transition to Replanning failed"); }
                 plan_tree = planner.replan(&goal, &plan_tree);
                 critic.reset_stall();
-                let _ = fsm.transition(AgentState::Planning);
-                let _ = fsm.transition(AgentState::Executing);
+                if let Err(e) = fsm.transition(AgentState::Planning) { tracing::debug!(error = %e, "FSM transition to Planning failed"); }
+                if let Err(e) = fsm.transition(AgentState::Executing) { tracing::debug!(error = %e, "FSM transition to Executing failed"); }
             }
             CriticSignal::Terminate { reason } => {
                 warn!(round = round, reason = %reason, "Critic terminating loop");
-                let _ = fsm.transition(AgentState::Terminating);
+                if let Err(e) = fsm.transition(AgentState::Terminating) { tracing::debug!(error = %e, "FSM transition to Terminating failed"); }
                 break 'agent;
             }
         }
@@ -483,13 +483,19 @@ pub async fn run_gdem_loop(user_message: &str, mut ctx: GdemContext) -> Result<G
 
     // ── Prepare persistence data ───────────────────────────────────────────
     let updated_strategy_learner_json = if ctx.config.enable_strategy_learning {
-        strategy_learner.to_json().ok()
+        strategy_learner.to_json().map_err(|e| {
+            tracing::warn!("Strategy learner serialization failed: {e}");
+            e
+        }).ok()
     } else {
         None
     };
 
     let updated_memory_bytes = if ctx.config.enable_memory {
-        memory.to_bytes().ok()
+        memory.to_bytes().map_err(|e| {
+            tracing::warn!("Memory serialization failed: {e}");
+            e
+        }).ok()
     } else {
         None
     };

crates/halcon-api/src/server/handlers/chat.rs

@@ -393,7 +393,9 @@ pub async fn resolve_permission(
 
     // Forward decision to executor via perm_senders.
     if let Some(tx) = state.perm_senders.get(&session_id) {
-        let _ = tx.send((request_id, approved));
+        if let Err(e) = tx.send((request_id, approved)) {
+            tracing::error!(session_id = %session_id, request_id = %request_id, "Permission decision channel closed: {e}");
+        }
     }
 
     state.broadcast(WsServerEvent::PermissionResolved {

crates/halcon-desktop/src/views/chat.rs

@@ -28,19 +28,23 @@ pub fn render(ui: &mut egui::Ui, state: &mut AppState, cmd_tx: &mpsc::Sender<UiC
         match outcome {
             PermissionOutcome::Approved => {
                 state.chat.permission_modal = None;
-                let _ = cmd_tx.try_send(UiCommand::ResolvePermission {
+                if let Err(e) = cmd_tx.try_send(UiCommand::ResolvePermission {
                     session_id,
                     request_id: modal.request_id,
                     approve: true,
-                });
+                }) {
+                    tracing::error!("Failed to send permission approval: {e}");
+                }
             }
             PermissionOutcome::Denied => {
                 state.chat.permission_modal = None;
-                let _ = cmd_tx.try_send(UiCommand::ResolvePermission {
+                if let Err(e) = cmd_tx.try_send(UiCommand::ResolvePermission {
                     session_id,
                     request_id: modal.request_id,
                     approve: false,
-                });
+                }) {
+                    tracing::error!("Failed to send permission denial: {e}");
+                }
             }
             PermissionOutcome::Pending => {}
         }
@@ -600,16 +604,21 @@ fn render_input_area(
             // Cache for potential retry if the turn fails with recoverable=true.
             state.chat.last_message = Some((content.clone(), orchestrate));
             state.chat.retry_count = 0;
-            let _ = cmd_tx.try_send(UiCommand::SendChatMessage {
+            if let Err(e) = cmd_tx.try_send(UiCommand::SendChatMessage {
                 session_id,
                 content,
                 orchestrate,
                 attachments,
-            });
+            }) {
+                tracing::error!("Failed to send chat message: {e}");
+                state.chat.is_streaming = false;
+            }
         }
 
         if is_busy && ui.button("Cancel").clicked() {
-            let _ = cmd_tx.try_send(UiCommand::CancelChatExecution { session_id });
+            if let Err(e) = cmd_tx.try_send(UiCommand::CancelChatExecution { session_id }) {
+                tracing::warn!("Failed to send cancellation: {e}");
+            }
         }
     });
 }

crates/halcon-runtime-events/src/bus.rs

@@ -97,7 +97,9 @@ impl EventBus {
         let event = RuntimeEvent::new(session_id, kind);
         // `send` returns Err if there are no receivers — that is fine; the bus
         // may have zero subscribers during early startup or in test runs.
-        let _ = self.sender.send(event);
+        if self.sender.send(event).is_err() {
+            tracing::trace!("Event bus: no subscribers (dropped event)");
+        }
     }
 
     /// Subscribe to the event stream, receiving all future events.