diff --git a/src/app/(dashboard)/dashboard/conductor/FaroChat.tsx b/src/app/(dashboard)/dashboard/conductor/FaroChat.tsx
new file mode 100644
index 0000000000..d1406d4663
--- /dev/null
+++ b/src/app/(dashboard)/dashboard/conductor/FaroChat.tsx
@@ -0,0 +1,272 @@
+"use client";
+
+/**
+ * Faro chat with voice (Conductor PRD RF4). Text: input → /api/conductor/ask
+ * (server-side proxy — the hub credential never reaches the browser). When the
+ * answer carries `pending`, Faro is asking for confirmation: the Sim/Não
+ * buttons just send "sim"/"não" — the safety gate lives in Faro's engine.
+ *
+ * Voice (guaranteed cycle, PRD RF4): push-to-talk → MediaRecorder →
+ * POST /api/v1/audio/transcriptions (multipart) → text → /ask → response →
+ * POST /api/v1/audio/speech → play the returned audio blob. STT/TTS models are
+ * operator-configurable (provider/model of THIS OmniRoute install), persisted
+ * in localStorage.
+ */
+
+import { useEffect, useRef, useState } from "react";
+import { useTranslations } from "next-intl";
+
+import { Badge, Card } from "@/shared/components";
+
+interface ChatMessage {
+ role: "user" | "faro";
+ text: string;
+}
+
+type VoiceState = "idle" | "listening" | "thinking" | "speaking";
+
+const STT_KEY = "conductor.sttModel";
+const TTS_KEY = "conductor.ttsModel";
+
+function safeGet(key: string, fallback: string): string {
+ try {
+ return localStorage.getItem(key) || fallback;
+ } catch {
+ return fallback;
+ }
+}
+
+async function errorMessageOf(res: Response, fallback: string): Promise
{
+ try {
+ const data = await res.json();
+ return data?.error?.message ?? fallback;
+ } catch {
+ return fallback;
+ }
+}
+
+export default function FaroChat() {
+ const t = useTranslations("conductor");
+ const [messages, setMessages] = useState([]);
+ const [input, setInput] = useState("");
+ const [pending, setPending] = useState(false);
+ const [busy, setBusy] = useState(false);
+ const [voice, setVoice] = useState("idle");
+ const [speak, setSpeak] = useState(false);
+ const [sttModel, setSttModel] = useState("openai/whisper-1");
+ const [ttsModel, setTtsModel] = useState("openai/tts-1");
+ const [err, setErr] = useState("");
+ const recorderRef = useRef(null);
+ const logRef = useRef(null);
+
+ useEffect(() => {
+ setSttModel(safeGet(STT_KEY, "openai/whisper-1"));
+ setTtsModel(safeGet(TTS_KEY, "openai/tts-1"));
+ }, []);
+ useEffect(() => {
+ logRef.current?.scrollTo({ top: logRef.current.scrollHeight });
+ }, [messages]);
+
+ const persistModels = (stt: string, tts: string) => {
+ setSttModel(stt);
+ setTtsModel(tts);
+ try {
+ localStorage.setItem(STT_KEY, stt);
+ localStorage.setItem(TTS_KEY, tts);
+ } catch {
+ // modo privado: segue só em memória
+ }
+ };
+
+ const playAnswer = async (text: string) => {
+ setVoice("speaking");
+ try {
+ const res = await fetch("/api/v1/audio/speech", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ model: ttsModel, input: text }),
+ });
+ if (!res.ok) {
+ setErr(await errorMessageOf(res, t("ttsFailed")));
+ return;
+ }
+ const url = URL.createObjectURL(await res.blob());
+ const audio = new Audio(url);
+ await audio.play().catch(() => undefined);
+ audio.onended = () => URL.revokeObjectURL(url);
+ } finally {
+ setVoice("idle");
+ }
+ };
+
+ const send = async (message: string, viaVoice = false) => {
+ const clean = message.trim();
+ if (!clean || busy) return;
+ setErr("");
+ setBusy(true);
+ setVoice("thinking");
+ setMessages((m) => [...m, { role: "user", text: clean }]);
+ setInput("");
+ try {
+ const res = await fetch("/api/conductor/ask", {
+ method: "POST",
+ headers: { "Content-Type": "application/json" },
+ body: JSON.stringify({ message: clean }),
+ });
+ if (!res.ok) {
+ setErr(await errorMessageOf(res, t("faroOffline")));
+ return;
+ }
+ const data = await res.json();
+ setMessages((m) => [...m, { role: "faro", text: data.text }]);
+ setPending(Boolean(data.pending));
+ if (viaVoice && speak && data.text) await playAnswer(data.text);
+ } catch {
+ setErr(t("faroOffline"));
+ } finally {
+ setBusy(false);
+ setVoice((v) => (v === "thinking" ? "idle" : v));
+ }
+ };
+
+ const startRecording = async () => {
+ setErr("");
+ try {
+ const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+ const recorder = new MediaRecorder(stream);
+ const chunks: Blob[] = [];
+ recorder.ondataavailable = (e) => e.data.size > 0 && chunks.push(e.data);
+ recorder.onstop = async () => {
+ stream.getTracks().forEach((track) => track.stop());
+ setVoice("thinking");
+ const blob = new Blob(chunks, { type: recorder.mimeType || "audio/webm" });
+ const form = new FormData();
+ form.append("model", sttModel);
+ form.append("file", new File([blob], "faro-ptt.webm", { type: blob.type }));
+ try {
+ // multipart: sem header manual — o browser define o boundary
+ const res = await fetch("/api/v1/audio/transcriptions", { method: "POST", body: form });
+ if (!res.ok) {
+ setErr(await errorMessageOf(res, t("sttFailed")));
+ setVoice("idle");
+ return;
+ }
+ const data = await res.json();
+ if (data.text) await send(data.text, true);
+ else setVoice("idle");
+ } catch {
+ setErr(t("sttFailed"));
+ setVoice("idle");
+ }
+ };
+ recorderRef.current = recorder;
+ recorder.start();
+ setVoice("listening");
+ } catch {
+ setErr(t("micDenied"));
+ }
+ };
+
+ const stopRecording = () => {
+ if (recorderRef.current?.state === "recording") recorderRef.current.stop();
+ recorderRef.current = null;
+ };
+
+ const voiceLabel: Record = {
+ idle: t("voiceIdle"),
+ listening: t("voiceListening"),
+ thinking: t("voiceThinking"),
+ speaking: t("voiceSpeaking"),
+ };
+
+ return (
+
+
+
+ {messages.length === 0 &&
{t("faroEmpty")}
}
+ {messages.map((m, i) => (
+
+
+ {m.text}
+
+
+ ))}
+
+
+ {err &&
{err}}
+ {pending && (
+
+ {t("faroPending")}
+
+
+
+ )}
+
+
+ setInput(e.target.value)}
+ onKeyDown={(e) => {
+ if (e.key === "Enter") void send(input);
+ }}
+ disabled={busy}
+ />
+
+
+
+
+
+
+ {t("voiceModels")}
+
+
+
+
+
+