audit(round2): check all error returns — zero silent failures across system

- websocket.go: sendMessage() checks Marshal+WriteMessage errors
- websocket.go: audioGeminiToClient() breaks after 10 consecutive errors, notifies client
- websocket.go: SendAudio error now notifies client with error message
- voice/handler.go: SendText/SendAudio errors checked and logged
- browser_voice_handler.go: SendAudio/SendImage/SendText errors checked
- eva_handler.go: SendText error checked, notifies browser on failure
- crisis/notifier.go: NotifyPsychologist returns error when ALL channels fail
- crisis/notifier.go: json.Marshal errors checked in email/SMS fallbacks
- whatsapp/service.go: json.Marshal and http.NewRequest errors checked

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: dfredmota999

browser_voice_handler.go

@@ -637,22 +637,28 @@ func (s *SignalingServer) handleBrowserVoice(w http.ResponseWriter, r *http.Requ
 			case "audio":
 				pcmData, err := base64.StdEncoding.DecodeString(msg.Data)
 				if err == nil {
-					client.SendAudio(pcmData)
+					if err := client.SendAudio(pcmData); err != nil {
+						log.Error().Err(err).Str("session", sessionID).Msg("[Browser] Erro ao enviar audio para Gemini")
+					}
 					if s.speakerSvc != nil {
 						go s.speakerSvc.ProcessAudioChunk(sessionID, clientCPF, pcmData)
 					}
 				}
 			case "video":
 				jpegData, err := base64.StdEncoding.DecodeString(msg.Data)
 				if err == nil {
-					client.SendImage(jpegData)
+					if err := client.SendImage(jpegData); err != nil {
+						log.Error().Err(err).Str("session", sessionID).Msg("[Browser] Erro ao enviar imagem para Gemini")
+					}
 				}
 			case "text":
 				if msg.Text != "" {
 					if s.evaMemory != nil {
 						go s.evaMemory.StoreTurn(ctx, sessionID, "user", msg.Text)
 					}
-					client.SendText(msg.Text)
+					if err := client.SendText(msg.Text); err != nil {
+						log.Error().Err(err).Str("session", sessionID).Msg("[Browser] Erro ao enviar texto para Gemini")
+					}
 				}
 			case "config":
 				log.Info().Str("session", sessionID).Msg("Browser sent config update")

eva_handler.go

@@ -267,7 +267,12 @@ func (s *SignalingServer) handleEvaChat(w http.ResponseWriter, r *http.Request)
 					transcriptMu.Lock()
 					transcriptAccum.WriteString("Usuario: " + msg.Text + "\n")
 					transcriptMu.Unlock()
-					geminiClient.SendText(msg.Text)
+					if err := geminiClient.SendText(msg.Text); err != nil {
+						log.Error().Err(err).Str("session", sessionID).Msg("[EVA] Erro ao enviar texto para Gemini")
+						writeMu.Lock()
+						conn.WriteJSON(evaMessage{Type: "status", Text: "error: falha ao enviar mensagem"})
+						writeMu.Unlock()
+					}
 				}
 			}
 		}

internal/clinical/crisis/notifier.go

@@ -93,30 +93,48 @@ func (n *Notifier) NotifyPsychologist(ctx context.Context, event *CrisisEvent) e
 		RequiresAction:   event.ResponseActions["require_acknowledgment"],
 	}
 
+	var errors []string
+
 	// 1. Send webhook (real-time)
 	if n.webhookURL != "" {
-		err := n.sendWebhook(ctx, payload)
-		if err != nil {
+		if err := n.sendWebhook(ctx, payload); err != nil {
 			log.Error().Err(err).Msg("Failed to send webhook")
+			errors = append(errors, "webhook: "+err.Error())
 		}
 	}
 
 	// 2. Send email (backup)
-	if n.emailAPI != "" {
-		err := n.sendEmail(ctx, payload)
-		if err != nil {
+	if n.emailAPI != "" || n.emailSvc != nil {
+		if err := n.sendEmail(ctx, payload); err != nil {
 			log.Error().Err(err).Msg("Failed to send email")
+			errors = append(errors, "email: "+err.Error())
 		}
 	}
 
 	// 3. Send SMS (critical only)
-	if event.Severity == "CRITICAL" && n.smsAPI != "" {
-		err := n.sendSMS(ctx, payload)
-		if err != nil {
+	if event.Severity == "CRITICAL" && (n.smsAPI != "" || n.smsSvc != nil) {
+		if err := n.sendSMS(ctx, payload); err != nil {
 			log.Error().Err(err).Msg("Failed to send SMS")
+			errors = append(errors, "sms: "+err.Error())
 		}
 	}
 
+	// Se NENHUM canal conseguiu enviar, retorna erro
+	channelsAttempted := 0
+	if n.webhookURL != "" {
+		channelsAttempted++
+	}
+	if n.emailAPI != "" || n.emailSvc != nil {
+		channelsAttempted++
+	}
+	if event.Severity == "CRITICAL" && (n.smsAPI != "" || n.smsSvc != nil) {
+		channelsAttempted++
+	}
+
+	if channelsAttempted > 0 && len(errors) == channelsAttempted {
+		return fmt.Errorf("CRITICO: todos os %d canais de notificacao falharam para evento %d: %v", channelsAttempted, event.ID, errors)
+	}
+
 	return nil
 }
 
@@ -179,7 +197,10 @@ func (n *Notifier) sendEmail(ctx context.Context, payload NotificationPayload) e
 			"subject": subject,
 			"payload": payload,
 		}
-		jsonData, _ := json.Marshal(emailPayload)
+		jsonData, err := json.Marshal(emailPayload)
+		if err != nil {
+			return fmt.Errorf("marshal email payload: %w", err)
+		}
 		req, err := http.NewRequestWithContext(ctx, "POST", n.emailAPI, bytes.NewBuffer(jsonData))
 		if err != nil {
 			return err
@@ -222,7 +243,10 @@ func (n *Notifier) sendSMS(ctx context.Context, payload NotificationPayload) err
 			"message": reason,
 			"payload": payload,
 		}
-		jsonData, _ := json.Marshal(smsPayload)
+		jsonData, err := json.Marshal(smsPayload)
+		if err != nil {
+			return fmt.Errorf("marshal sms payload: %w", err)
+		}
 		req, err := http.NewRequestWithContext(ctx, "POST", n.smsAPI, bytes.NewBuffer(jsonData))
 		if err != nil {
 			return err

internal/motor/whatsapp/service.go

@@ -38,8 +38,14 @@ func (s *Service) SendMessage(to, message string) error {
 		},
 	}
 
-	body, _ := json.Marshal(payload)
-	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("marshal payload: %w", err)
+	}
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
+	if err != nil {
+		return fmt.Errorf("create request: %w", err)
+	}
 	req.Header.Set("Authorization", "Bearer "+s.accessToken)
 	req.Header.Set("Content-Type", "application/json")
 
@@ -85,8 +91,14 @@ func (s *Service) SendTemplateMessage(to, templateName string, params []string)
 		},
 	}
 
-	body, _ := json.Marshal(payload)
-	req, _ := http.NewRequest("POST", url, bytes.NewBuffer(body))
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("marshal template payload: %w", err)
+	}
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(body))
+	if err != nil {
+		return fmt.Errorf("create template request: %w", err)
+	}
 	req.Header.Set("Authorization", "Bearer "+s.accessToken)
 	req.Header.Set("Content-Type", "application/json")
 

internal/senses/signaling/websocket.go

@@ -743,7 +743,11 @@ Use isso para guiar sua resposta ao próximo áudio.
 	}
 
 	if err := session.GeminiClient.SendAudio(pcmData); err != nil {
-		log.Printf("❌ Erro ao enviar áudio para Gemini")
+		log.Printf("❌ [SendAudio] Erro ao enviar audio para Gemini (session=%s): %v", session.ID, err)
+		s.sendMessage(session.WSConn, ControlMessage{
+			Type:  "error",
+			Error: "Falha ao enviar audio para IA: " + err.Error(),
+		})
 	}
 }
 
@@ -752,17 +756,33 @@ func (s *SignalingServer) audioClientToGemini(session *WebSocketSession) {
 }
 
 func (s *SignalingServer) audioGeminiToClient(session *WebSocketSession) {
+	consecutiveErrors := 0
+	const maxConsecutiveErrors = 10
+
 	for {
 		select {
 		case <-session.ctx.Done():
 			return
 		default:
 			response, err := session.GeminiClient.ReadResponse()
 			if err != nil {
+				consecutiveErrors++
+				log.Printf("⚠️ [audioGeminiToClient] Erro Gemini (%d/%d): %v", consecutiveErrors, maxConsecutiveErrors, err)
+
+				if consecutiveErrors >= maxConsecutiveErrors {
+					log.Printf("❌ [audioGeminiToClient] %d erros consecutivos — encerrando sessao %s", maxConsecutiveErrors, session.ID)
+					s.sendMessage(session.WSConn, ControlMessage{
+						Type:  "error",
+						Error: fmt.Sprintf("Conexao com IA perdida apos %d tentativas", maxConsecutiveErrors),
+					})
+					return
+				}
+
 				time.Sleep(100 * time.Millisecond)
 				continue
 			}
 
+			consecutiveErrors = 0
 			s.handleGeminiResponse(session, response)
 		}
 	}
@@ -1683,8 +1703,14 @@ func (s *SignalingServer) getIdosoByCPF(cpf string) (*Idoso, error) {
 }
 
 func (s *SignalingServer) sendMessage(conn *websocket.Conn, msg ControlMessage) {
-	data, _ := json.Marshal(msg)
-	conn.WriteMessage(websocket.TextMessage, data)
+	data, err := json.Marshal(msg)
+	if err != nil {
+		log.Printf("❌ [sendMessage] Erro ao serializar mensagem type=%s: %v", msg.Type, err)
+		return
+	}
+	if err := conn.WriteMessage(websocket.TextMessage, data); err != nil {
+		log.Printf("❌ [sendMessage] Erro ao enviar mensagem type=%s: %v", msg.Type, err)
+	}
 }
 
 func (s *SignalingServer) sendError(conn *websocket.Conn, errMsg string) {

internal/voice/handler.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"encoding/base64"
 	"encoding/binary"
+	"fmt"
 	"eva-mind/internal/brainstem/config"
 	"eva-mind/internal/brainstem/database"
 	"eva-mind/internal/cortex/gemini"
@@ -235,7 +236,11 @@ func (h *Handler) HandleMediaStream(w http.ResponseWriter, r *http.Request) {
 						if sid, ok := start["streamSid"].(string); ok {
 							streamSidChan <- sid
 							// Inicia a conversa
-							geminiSession.Client.SendText("O usuário atendeu. Diga 'Olá'.")
+							if err := geminiSession.Client.SendText("O usuário atendeu. Diga 'Olá'."); err != nil {
+								h.logger.Error().Err(err).Msg("Erro ao enviar texto inicial para Gemini")
+								errChan <- fmt.Errorf("gemini SendText: %w", err)
+								return
+							}
 						}
 					}
 				case "media":
@@ -255,7 +260,9 @@ func (h *Handler) HandleMediaStream(w http.ResponseWriter, r *http.Request) {
 
 							// Flush se buffer cheio
 							if len(audioSess.AudioBuffer) >= MIN_BUFFER_SIZE {
-								geminiSession.Client.SendAudio(audioSess.AudioBuffer)
+								if err := geminiSession.Client.SendAudio(audioSess.AudioBuffer); err != nil {
+									h.logger.Error().Err(err).Msg("Erro ao enviar audio para Gemini")
+								}
 								// Reset buffer mantendo capacidade
 								audioSess.AudioBuffer = audioSess.AudioBuffer[:0]
 							}