@leg3ndy/otto-bridge 0.8.1 → 0.8.3

package/dist/executors/native_macos.js

@@ -7,6 +7,7 @@ import { JobCancelledError } from "./shared.js";
 import { loadManagedBridgeExtensionState, saveManagedBridgeExtensionState, } from "../extensions.js";
 import { postDeviceJson, uploadDeviceJobArtifact } from "../http.js";
 import { WHATSAPP_WEB_URL, WhatsAppBackgroundBrowser, } from "../whatsapp_background.js";
+import { verifyExpectedWhatsAppMessage } from "../whatsapp_verification.js";
 const KNOWN_APPS = [
     { canonical: "Safari", patterns: [/\bsafari\b/i] },
     { canonical: "Google Chrome", patterns: [/\bgoogle chrome\b/i, /\bchrome\b/i] },
@@ -221,6 +222,136 @@ function descriptionWantsPause(description) {
 function descriptionWantsResume(description) {
     return /\b(retoma|retomar|resume|continu[ae]r|despausa|play)\b/.test(normalizeText(description || ""));
 }
+function descriptionWantsSpotifyTrackPageOpen(description) {
+    const normalized = normalizeText(description || "");
+    return /\bspotify\b/.test(normalized)
+        && /\b(pagina|titulo|nome|link)\b/.test(normalized)
+        && /\b(faixa|musica|track)\b/.test(normalized);
+}
+function descriptionWantsSpotifyTrackPagePlay(description) {
+    const normalized = normalizeText(description || "");
+    return /\bspotify\b/.test(normalized)
+        && /\b(play|reproduzir|tocar|verde|principal)\b/.test(normalized)
+        && /\b(pagina|faixa|musica|track)\b/.test(normalized);
+}
+function isSpotifySafariDomOnlyStep(description) {
+    return descriptionWantsSpotifyTrackPageOpen(description) || descriptionWantsSpotifyTrackPagePlay(description);
+}
+function playerStateLooksActive(playerState) {
+    const normalized = normalizeText(playerState || "");
+    return normalized.includes("pause") || normalized.includes("pausar");
+}
+function browserStateMatchesSpotifyTrackDescription(state, description) {
+    if (!state) {
+        return false;
+    }
+    const normalizedUrl = normalizeComparableUrl(state.url || "");
+    if (!normalizedUrl.includes("open.spotify.com/track/")) {
+        return false;
+    }
+    const haystack = [
+        state.playerTitle || "",
+        state.title || "",
+        String(state.text || "").slice(0, 4000),
+    ].join(" ");
+    const normalizedHaystack = normalizeText(haystack);
+    if (!normalizedHaystack) {
+        return false;
+    }
+    const quotedPhrases = extractQuotedPhrases(description);
+    if (quotedPhrases.some((phrase) => normalizedHaystack.includes(phrase))) {
+        return true;
+    }
+    const mediaQueryTokens = extractMediaQueryTokens(description);
+    if (!mediaQueryTokens.length) {
+        return false;
+    }
+    const matchCount = countMatchingTokens(haystack, mediaQueryTokens);
+    return matchCount >= Math.max(1, Math.ceil(mediaQueryTokens.length * 0.5));
+}
+function spotifyStateContentMatchesDescription(state, description) {
+    if (!state) {
+        return false;
+    }
+    const normalizedUrl = normalizeComparableUrl(state.url || "");
+    if (!normalizedUrl.includes("open.spotify.com")) {
+        return false;
+    }
+    const haystack = [
+        state.playerTitle || "",
+        state.title || "",
+        String(state.text || "").slice(0, 4000),
+    ].join(" ");
+    const normalizedHaystack = normalizeText(haystack);
+    if (!normalizedHaystack) {
+        return false;
+    }
+    const quotedPhrases = extractQuotedPhrases(description);
+    if (quotedPhrases.some((phrase) => normalizedHaystack.includes(phrase))) {
+        return true;
+    }
+    const mediaQueryTokens = extractMediaQueryTokens(description);
+    if (!mediaQueryTokens.length) {
+        return false;
+    }
+    const matchCount = countMatchingTokens(haystack, mediaQueryTokens);
+    return matchCount >= Math.max(1, Math.ceil(mediaQueryTokens.length * 0.5));
+}
+function spotifyPlayerAlreadyPlayingMatchesDescription(state, description) {
+    if (!state) {
+        return false;
+    }
+    const normalizedUrl = normalizeComparableUrl(state.url || "");
+    if (!normalizedUrl.includes("open.spotify.com")) {
+        return false;
+    }
+    if (!playerStateLooksActive(state.playerState || "")) {
+        return false;
+    }
+    const haystack = [
+        state.playerTitle || "",
+        state.title || "",
+        String(state.text || "").slice(0, 4000),
+    ].join(" ");
+    const normalizedHaystack = normalizeText(haystack);
+    if (!normalizedHaystack) {
+        return false;
+    }
+    const quotedPhrases = extractQuotedPhrases(description);
+    if (quotedPhrases.some((phrase) => normalizedHaystack.includes(phrase))) {
+        return true;
+    }
+    const mediaQueryTokens = extractMediaQueryTokens(description);
+    if (!mediaQueryTokens.length) {
+        return false;
+    }
+    const matchCount = countMatchingTokens(haystack, mediaQueryTokens);
+    return matchCount >= Math.max(1, Math.ceil(mediaQueryTokens.length * 0.5));
+}
+function spotifyTrackAlreadyPlayingMatchesDescription(state, description) {
+    return browserStateMatchesSpotifyTrackDescription(state, description)
+        && spotifyPlayerAlreadyPlayingMatchesDescription(state, description);
+}
+function spotifyTrackPageLooksPlaying(state, description) {
+    return browserStateMatchesSpotifyTrackDescription(state, description)
+        && playerStateLooksActive(state?.playerState || "");
+}
+function spotifyDescriptionsLikelyMatch(left, right) {
+    const leftPhrases = new Set(extractQuotedPhrases(left));
+    const rightPhrases = new Set(extractQuotedPhrases(right));
+    for (const phrase of leftPhrases) {
+        if (rightPhrases.has(phrase)) {
+            return true;
+        }
+    }
+    const leftTokens = extractMediaQueryTokens(left);
+    const rightTokens = new Set(extractMediaQueryTokens(right));
+    if (!leftTokens.length || !rightTokens.size) {
+        return false;
+    }
+    const overlap = leftTokens.filter((token) => rightTokens.has(token)).length;
+    return overlap >= Math.max(1, Math.ceil(Math.min(leftTokens.length, rightTokens.size) * 0.5));
+}
 function extractNativeMediaTransportCommand(description) {
     const normalizedDescription = normalizeText(description || "");
     if (!normalizedDescription
@@ -473,6 +604,10 @@ function urlHostname(url) {
         return null;
     }
 }
+function isSpotifySearchUrl(url) {
+    const normalized = normalizeComparableUrl(normalizeUrl(url));
+    return normalized.includes("open.spotify.com/search/");
+}
 function uniqueStrings(values) {
     const seen = new Set();
     const result = [];
@@ -971,6 +1106,9 @@ export class NativeMacOSJobExecutor {
     lastActiveApp = null;
     lastVisualTargetDescription = null;
     lastVisualTargetApp = null;
+    lastSatisfiedSpotifyDescription = null;
+    lastSatisfiedSpotifyConfirmedPlaying = false;
+    lastSatisfiedSpotifyAt = 0;
     whatsappBackgroundBrowser = null;
     whatsappRuntimeMonitor = null;
     constructor(bridgeConfig) {
@@ -987,6 +1125,9 @@ export class NativeMacOSJobExecutor {
         if (actions.length === 0) {
             throw new Error("Otto Bridge native-macos could not derive a supported local action from this request");
         }
+        this.lastSatisfiedSpotifyDescription = null;
+        this.lastSatisfiedSpotifyConfirmedPlaying = false;
+        this.lastSatisfiedSpotifyAt = 0;
         await reporter.accepted();
         const confirmation = extractConfirmationOptions(job, actions);
         if (confirmation.required) {
@@ -1025,7 +1166,7 @@ export class NativeMacOSJobExecutor {
                 }
                 if (action.type === "press_shortcut") {
                     await reporter.progress(progressPercent, `Enviando atalho ${action.shortcut}`);
-                    await this.pressShortcut(action.shortcut);
+                    const shortcutResult = await this.pressShortcut(action.shortcut);
                     if (action.shortcut.startsWith("media_")) {
                         const mediaSummaryMap = {
                             media_next: "Acionei o comando de próxima mídia no macOS.",
@@ -1035,7 +1176,14 @@ export class NativeMacOSJobExecutor {
                             media_play: "Acionei o comando de reproduzir mídia no macOS.",
                             media_play_pause: "Acionei o comando de play/pause de mídia no macOS.",
                         };
-                        completionNotes.push(mediaSummaryMap[action.shortcut] || `Acionei ${action.shortcut} no macOS.`);
+                        const mediaSkippedSummaryMap = {
+                            media_pause: "Nenhuma mídia estava tocando no macOS, então o pause global foi pulado.",
+                            media_resume: "Já havia mídia tocando no macOS, então o comando de retomar foi pulado.",
+                            media_play: "Já havia mídia tocando no macOS, então o comando de reproduzir foi pulado.",
+                        };
+                        completionNotes.push(shortcutResult.performed
+                            ? (mediaSummaryMap[action.shortcut] || `Acionei ${action.shortcut} no macOS.`)
+                            : (mediaSkippedSummaryMap[action.shortcut] || shortcutResult.reason || `O atalho ${action.shortcut} foi pulado no macOS.`));
                     }
                     continue;
                 }
@@ -1197,10 +1345,6 @@ export class NativeMacOSJobExecutor {
                     await reporter.progress(progressPercent, `Enviando a mensagem para ${action.contact} no WhatsApp`);
                     await this.sendWhatsAppMessage(action.text);
                     await delay(900);
-                    const verification = await this.verifyWhatsAppLastMessageAgainstBaseline(action.text, beforeSend.messages);
-                    if (!verification.ok) {
-                        throw new Error(verification.reason || `Nao consegui confirmar o envio da mensagem para ${action.contact} no WhatsApp.`);
-                    }
                     const afterSend = await this.readWhatsAppVisibleConversation(action.contact, Math.max(12, beforeSend.messages.length + 4)).catch(() => null);
                     resultPayload.whatsapp = {
                         action: "send_message",
@@ -1209,6 +1353,12 @@ export class NativeMacOSJobExecutor {
                         messages: afterSend?.messages || [],
                         summary: afterSend?.summary || "",
                     };
+                    const verification = await this.verifyWhatsAppLastMessageAgainstBaseline(action.text, beforeSend.messages);
+                    if (!verification.ok) {
+                        resultPayload.summary = verification.reason || `Nao consegui confirmar o envio da mensagem para ${action.contact} no WhatsApp.`;
+                        await reporter.failed(verification.reason || `Nao consegui confirmar o envio da mensagem para ${action.contact} no WhatsApp.`, resultPayload);
+                        return;
+                    }
                     completionNotes.push(`Enviei no WhatsApp para ${action.contact}: ${clipText(action.text, 180)}`);
                     continue;
                 }
@@ -1239,7 +1389,9 @@ export class NativeMacOSJobExecutor {
                         await reporter.progress(progressPercent, `Trazendo ${action.app} para frente antes do clique`);
                         await this.focusApp(action.app);
                     }
-                    const targetDescriptions = uniqueStrings([action.description, ...(action.retry_descriptions || [])]);
+                    const targetDescriptions = isSpotifySafariDomOnlyStep(action.description)
+                        ? [action.description]
+                        : uniqueStrings([action.description, ...(action.retry_descriptions || [])]);
                     let clickSucceeded = false;
                     let lastFailureReason = "";
                     for (let attempt = 0; attempt < targetDescriptions.length; attempt += 1) {
@@ -1247,6 +1399,33 @@ export class NativeMacOSJobExecutor {
                         const initialBrowserState = browserApp
                             ? await this.captureBrowserPageState(browserApp).catch(() => null)
                             : null;
+                        const isSpotifySafariStep = browserApp === "Safari" && isSpotifySafariDomOnlyStep(targetDescription);
+                        const verificationPrompt = isSpotifySafariStep ? undefined : action.verification_prompt;
+                        if (isSpotifySafariStep) {
+                            await reporter.progress(progressPercent, `Tentando concluir ${targetDescription} pelo DOM do Spotify no Safari`);
+                            const spotifyDomResult = await this.executeSpotifySafariDomStep(targetDescription, initialBrowserState);
+                            if (spotifyDomResult.ok) {
+                                this.rememberSatisfiedSpotifyStep(targetDescription, !!spotifyDomResult.confirmedPlaying);
+                                this.lastVisualTargetDescription = targetDescription;
+                                this.lastVisualTargetApp = browserApp || action.app || this.lastActiveApp;
+                                resultPayload.last_click = {
+                                    strategy: spotifyDomResult.skipped
+                                        ? "spotify_browser_state_skip"
+                                        : (spotifyDomResult.click?.strategy || "spotify_safari_dom"),
+                                    matched_text: spotifyDomResult.click?.matchedText || targetDescription,
+                                    matched_href: spotifyDomResult.click?.matchedHref || spotifyDomResult.afterState?.url || null,
+                                    score: spotifyDomResult.click?.score || null,
+                                    total_candidates: spotifyDomResult.click?.totalCandidates || null,
+                                };
+                                completionNotes.push(spotifyDomResult.skipped
+                                    ? `O Spotify Web ja estava no estado certo para ${targetDescription}, então pulei tentativas extras.`
+                                    : `Concluí ${targetDescription} diretamente pelo DOM do Spotify Web no Safari.`);
+                                clickSucceeded = true;
+                                break;
+                            }
+                            lastFailureReason = spotifyDomResult.reason || `Nao consegui concluir ${targetDescription} pelo DOM do Spotify Web no Safari.`;
+                            continue;
+                        }
                         const nativeMediaTransport = extractNativeMediaTransportCommand(targetDescription);
                         if (nativeMediaTransport) {
                             await reporter.progress(progressPercent, `Tentando controle de mídia nativo do macOS para ${targetDescription}`);
@@ -1259,8 +1438,8 @@ export class NativeMacOSJobExecutor {
                                     validated = browserValidation.ok;
                                     validationReason = browserValidation.reason;
                                 }
-                                if (!validated && action.verification_prompt) {
-                                    const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, action.verification_prompt, progressPercent, reporter, artifacts, "native_media_transport_result");
+                                if (!validated && verificationPrompt) {
+                                    const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, verificationPrompt, progressPercent, reporter, artifacts, "native_media_transport_result");
                                     if (verification.unavailable) {
                                         lastFailureReason = verification.reason;
                                         break;
@@ -1298,8 +1477,8 @@ export class NativeMacOSJobExecutor {
                                     validated = browserValidation.ok;
                                     validationReason = browserValidation.reason;
                                 }
-                                if (!validated && action.verification_prompt) {
-                                    const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, action.verification_prompt, progressPercent, reporter, artifacts, "dom_click_result");
+                                if (!validated && verificationPrompt) {
+                                    const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, verificationPrompt, progressPercent, reporter, artifacts, "dom_click_result");
                                     if (verification.unavailable) {
                                         lastFailureReason = verification.reason;
                                         break;
@@ -1344,8 +1523,8 @@ export class NativeMacOSJobExecutor {
                                 validated = browserValidation.ok;
                                 validationReason = browserValidation.reason;
                             }
-                            if (!validated && action.verification_prompt) {
-                                const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, action.verification_prompt, progressPercent, reporter, artifacts, "local_ocr_click_result");
+                            if (!validated && verificationPrompt) {
+                                const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, verificationPrompt, progressPercent, reporter, artifacts, "local_ocr_click_result");
                                 if (verification.unavailable) {
                                     lastFailureReason = verification.reason;
                                     break;
@@ -1425,8 +1604,8 @@ export class NativeMacOSJobExecutor {
                             y: scaledY,
                             strategy: "visual_locator",
                         };
-                        if (action.verification_prompt) {
-                            const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, action.verification_prompt, progressPercent, reporter, artifacts, "visual_click_result");
+                        if (verificationPrompt) {
+                            const verification = await this.validateVisualClickWithVision(job.job_id, targetDescription, verificationPrompt, progressPercent, reporter, artifacts, "visual_click_result");
                             if (verification.unavailable) {
                                 lastFailureReason = verification.reason;
                                 break;
@@ -1531,6 +1710,9 @@ export class NativeMacOSJobExecutor {
                 await this.runCommand("open", ["-a", app, url]);
             }
             await this.focusApp(app);
+            if (isSpotifySearchUrl(url)) {
+                await this.ensureSafariSpotifySearchUrl(url);
+            }
             this.lastActiveApp = app;
             return;
         }
@@ -1542,6 +1724,48 @@ export class NativeMacOSJobExecutor {
         }
         await this.runCommand("open", [url]);
     }
+    async ensureSafariSpotifySearchUrl(url) {
+        const targetUrl = normalizeUrl(url);
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            await delay(700);
+            const currentUrl = await this.readSafariCurrentUrl().catch(() => "");
+            const normalizedCurrentUrl = normalizeComparableUrl(currentUrl);
+            if (!normalizedCurrentUrl || !normalizedCurrentUrl.includes("open.spotify.com")) {
+                return;
+            }
+            if (normalizedCurrentUrl.includes("/search/")) {
+                return;
+            }
+            if (!/open\.spotify\.com\/?$/.test(normalizedCurrentUrl)) {
+                return;
+            }
+            await this.setSafariFrontTabUrl(targetUrl).catch(() => undefined);
+        }
+    }
+    async readSafariCurrentUrl() {
+        const script = `
+tell application "Safari"
+  if (count of windows) = 0 then return ""
+  try
+    return URL of current tab of front window
+  on error
+    return ""
+  end try
+end tell
+`;
+        const { stdout } = await this.runCommandCapture("osascript", ["-e", script]);
+        return String(stdout || "").trim();
+    }
+    async setSafariFrontTabUrl(url) {
+        const script = `
+set targetUrl to "${escapeAppleScript(url)}"
+tell application "Safari"
+  if (count of windows) = 0 then return
+  set URL of current tab of front window to targetUrl
+end tell
+`;
+        await this.runCommand("osascript", ["-e", script]);
+    }
     async tryReuseSafariTab(url) {
         const targetUrl = normalizeUrl(url);
         const targetHost = urlHostname(targetUrl);
@@ -1651,6 +1875,161 @@ end tell
             playerState: page.playerState || "",
         };
     }
+    rememberSatisfiedSpotifyStep(description, confirmedPlaying) {
+        if (!isSpotifySafariDomOnlyStep(description)) {
+            return;
+        }
+        this.lastSatisfiedSpotifyDescription = description;
+        this.lastSatisfiedSpotifyConfirmedPlaying = confirmedPlaying;
+        this.lastSatisfiedSpotifyAt = Date.now();
+    }
+    hasRecentSatisfiedSpotifyPlayback(description, maxAgeMs = 10_000) {
+        if (!this.lastSatisfiedSpotifyConfirmedPlaying || !this.lastSatisfiedSpotifyDescription || !this.lastSatisfiedSpotifyAt) {
+            return false;
+        }
+        if ((Date.now() - this.lastSatisfiedSpotifyAt) > maxAgeMs) {
+            return false;
+        }
+        return spotifyDescriptionsLikelyMatch(this.lastSatisfiedSpotifyDescription, description);
+    }
+    hasRecentSatisfiedSpotifyStep(description, maxAgeMs = 10_000) {
+        if (!this.lastSatisfiedSpotifyDescription || !this.lastSatisfiedSpotifyAt) {
+            return false;
+        }
+        if ((Date.now() - this.lastSatisfiedSpotifyAt) > maxAgeMs) {
+            return false;
+        }
+        return spotifyDescriptionsLikelyMatch(this.lastSatisfiedSpotifyDescription, description);
+    }
+    async executeSpotifySafariDomStep(targetDescription, initialBrowserState) {
+        if (descriptionWantsSpotifyTrackPagePlay(targetDescription)
+            && this.hasRecentSatisfiedSpotifyStep(targetDescription)
+            && browserStateMatchesSpotifyTrackDescription(initialBrowserState, targetDescription)) {
+            return {
+                ok: true,
+                skipped: true,
+                afterState: initialBrowserState,
+            };
+        }
+        if (descriptionWantsSpotifyTrackPagePlay(targetDescription) && this.hasRecentSatisfiedSpotifyPlayback(targetDescription)) {
+            return {
+                ok: true,
+                skipped: true,
+                confirmedPlaying: true,
+                afterState: initialBrowserState,
+            };
+        }
+        if (spotifyPlayerAlreadyPlayingMatchesDescription(initialBrowserState, targetDescription)) {
+            return {
+                ok: true,
+                skipped: true,
+                confirmedPlaying: true,
+                afterState: initialBrowserState,
+            };
+        }
+        if (descriptionWantsSpotifyTrackPagePlay(targetDescription)) {
+            const shouldWaitLongerForAutoplay = this.hasRecentSatisfiedSpotifyStep(targetDescription);
+            let settledState = initialBrowserState;
+            for (let attempt = 0; attempt < (shouldWaitLongerForAutoplay ? 6 : 3); attempt += 1) {
+                if (attempt > 0) {
+                    await delay(shouldWaitLongerForAutoplay ? 550 : 450);
+                }
+                settledState = await this.captureBrowserPageState("Safari").catch(() => settledState);
+                const playbackState = await this.readGlobalMediaPlaybackState();
+                if ((playbackState === "playing" && spotifyStateContentMatchesDescription(settledState, targetDescription))
+                    || spotifyTrackPageLooksPlaying(settledState, targetDescription)
+                    || spotifyTrackAlreadyPlayingMatchesDescription(settledState, targetDescription)) {
+                    return {
+                        ok: true,
+                        skipped: true,
+                        confirmedPlaying: true,
+                        afterState: settledState,
+                    };
+                }
+            }
+            const alreadyOnRequestedTrack = browserStateMatchesSpotifyTrackDescription(initialBrowserState, targetDescription);
+            if (alreadyOnRequestedTrack) {
+                const playbackState = await this.readGlobalMediaPlaybackState();
+                if (playbackState === "playing"
+                    || spotifyTrackPageLooksPlaying(initialBrowserState, targetDescription)
+                    || spotifyTrackAlreadyPlayingMatchesDescription(initialBrowserState, targetDescription)) {
+                    return {
+                        ok: true,
+                        skipped: true,
+                        confirmedPlaying: true,
+                        afterState: initialBrowserState,
+                    };
+                }
+            }
+        }
+        const domClick = await this.trySafariDomClick(targetDescription);
+        let currentState = await this.captureBrowserPageState("Safari").catch(() => initialBrowserState);
+        if (!domClick?.clicked) {
+            return {
+                ok: false,
+                reason: domClick?.reason || `Nao consegui concluir ${targetDescription} pelo DOM do Spotify Web no Safari.`,
+                afterState: currentState,
+            };
+        }
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            if (attempt > 0) {
+                await delay(500);
+            }
+            currentState = await this.captureBrowserPageState("Safari").catch(() => currentState);
+            if (descriptionWantsSpotifyTrackPageOpen(targetDescription)) {
+                if (browserStateMatchesSpotifyTrackDescription(currentState, targetDescription)) {
+                    return {
+                        ok: true,
+                        click: domClick,
+                        afterState: currentState,
+                    };
+                }
+                const playbackState = await this.readGlobalMediaPlaybackState();
+                if (playbackState === "playing" && spotifyStateContentMatchesDescription(currentState, targetDescription)) {
+                    return {
+                        ok: true,
+                        click: domClick,
+                        confirmedPlaying: true,
+                        afterState: currentState,
+                    };
+                }
+            }
+            if (descriptionWantsSpotifyTrackPagePlay(targetDescription)) {
+                if (spotifyPlayerAlreadyPlayingMatchesDescription(currentState, targetDescription)) {
+                    return {
+                        ok: true,
+                        click: domClick,
+                        confirmedPlaying: true,
+                        afterState: currentState,
+                    };
+                }
+                const playbackState = await this.readGlobalMediaPlaybackState();
+                if (playbackState === "playing" && spotifyStateContentMatchesDescription(currentState, targetDescription)) {
+                    return {
+                        ok: true,
+                        click: domClick,
+                        confirmedPlaying: true,
+                        afterState: currentState,
+                    };
+                }
+            }
+        }
+        if (descriptionWantsSpotifyTrackPageOpen(targetDescription)) {
+            const matchedHref = normalizeComparableUrl(domClick.matchedHref || "");
+            if (matchedHref.includes("/track/")) {
+                return {
+                    ok: true,
+                    click: domClick,
+                    afterState: currentState,
+                };
+            }
+        }
+        return {
+            ok: false,
+            reason: `O clique em ${targetDescription} nao mudou a pagina do navegador de forma verificavel.`,
+            afterState: currentState,
+        };
+    }
     resolveExpectedBrowserHref(rawHref, baseUrl) {
         const href = String(rawHref || "").trim();
         if (!href) {
@@ -1691,12 +2070,14 @@ end tell
         const afterPlayerTitle = normalizeText(after.playerTitle || "");
         const beforePlayerState = normalizeText(before?.playerState || "");
         const afterPlayerState = normalizeText(after.playerState || "");
-        const playerLooksActive = afterPlayerState.includes("pause") || afterPlayerState.includes("pausar");
+        const playerLooksActive = playerStateLooksActive(after.playerState || "");
         const playerLooksPaused = !playerLooksActive && /play|tocar|reproduzir|continuar|retomar|resume/.test(afterPlayerState);
         const wantsNext = descriptionWantsNext(targetDescription);
         const wantsPrevious = descriptionWantsPrevious(targetDescription);
         const wantsPause = descriptionWantsPause(targetDescription);
         const wantsResume = descriptionWantsResume(targetDescription);
+        const wantsSpotifyTrackPageOpen = descriptionWantsSpotifyTrackPageOpen(targetDescription);
+        const wantsSpotifyTrackPagePlay = descriptionWantsSpotifyTrackPagePlay(targetDescription);
         const mediaQueryTokens = extractMediaQueryTokens(targetDescription);
         const mediaMatchCount = countMatchingTokens(after.playerTitle || "", mediaQueryTokens);
         if (afterUrl.includes("music.youtube.com")) {
@@ -1722,6 +2103,51 @@ end tell
                 return true;
             }
         }
+        if (afterUrl.includes("open.spotify.com")) {
+            if (wantsSpotifyTrackPageOpen && spotifyPlayerAlreadyPlayingMatchesDescription(after, targetDescription)) {
+                return true;
+            }
+            if (wantsSpotifyTrackPagePlay && spotifyTrackAlreadyPlayingMatchesDescription(after, targetDescription)) {
+                return true;
+            }
+            if (wantsSpotifyTrackPageOpen) {
+                const beforeWasTrackPage = beforeUrl.includes("/track/");
+                const afterIsTrackPage = afterUrl.includes("/track/");
+                if (afterIsTrackPage && (!beforeWasTrackPage || beforeUrl !== afterUrl)) {
+                    return true;
+                }
+                return spotifyPlayerAlreadyPlayingMatchesDescription(after, targetDescription);
+            }
+            if (wantsPause && beforePlayerState && beforePlayerState !== afterPlayerState && playerLooksPaused) {
+                return true;
+            }
+            if (wantsResume && playerLooksActive && beforePlayerState !== afterPlayerState) {
+                return true;
+            }
+            if ((wantsNext || wantsPrevious) && beforePlayerTitle && afterPlayerTitle && beforePlayerTitle !== afterPlayerTitle) {
+                return true;
+            }
+            if (mediaQueryTokens.length >= 2) {
+                const requiredMatches = Math.max(2, Math.ceil(mediaQueryTokens.length * 0.5));
+                const titleLooksCorrect = mediaMatchCount >= requiredMatches;
+                const playerChanged = ((beforePlayerTitle && afterPlayerTitle && beforePlayerTitle !== afterPlayerTitle)
+                    || (!beforePlayerTitle && !!afterPlayerTitle)
+                    || (beforePlayerState && afterPlayerState && beforePlayerState !== afterPlayerState));
+                if (titleLooksCorrect && (playerChanged || (beforePlayerTitle === afterPlayerTitle && playerLooksActive))) {
+                    return true;
+                }
+            }
+            if (beforePlayerTitle && afterPlayerTitle && beforePlayerTitle !== afterPlayerTitle && playerLooksActive) {
+                return true;
+            }
+            if (!beforePlayerTitle && afterPlayerTitle && playerLooksActive) {
+                return true;
+            }
+        }
+        const looksLikeMediaAction = wantsNext || wantsPrevious || wantsPause || wantsResume || mediaQueryTokens.length > 0;
+        if (looksLikeMediaAction && (afterUrl.includes("music.youtube.com") || afterUrl.includes("open.spotify.com"))) {
+            return false;
+        }
         const beforeTitle = normalizeText(before?.title || "");
         const afterTitle = normalizeText(after.title || "");
         if (beforeTitle && afterTitle && beforeTitle !== afterTitle) {
@@ -1742,9 +2168,11 @@ end tell
                 afterState: null,
             };
         }
+        let lastAfterState = null;
         for (let attempt = 0; attempt < 4; attempt += 1) {
             await delay(attempt === 0 ? 900 : 700);
             const afterState = await this.captureBrowserPageState(app).catch(() => null);
+            lastAfterState = afterState;
             if (this.didBrowserPageStateChange(before, afterState, targetDescription, matchedHref)) {
                 return {
                     ok: true,
@@ -1756,7 +2184,7 @@ end tell
         return {
             ok: false,
             reason: `O clique em ${targetDescription} nao mudou a pagina do navegador de forma verificavel.`,
-            afterState: null,
+            afterState: lastAfterState,
         };
     }
     async pressShortcut(shortcut) {
@@ -1778,8 +2206,28 @@ end tell
         };
         const mediaCommand = mediaCommandMap[normalizedShortcut];
         if (mediaCommand) {
+            if (normalizedShortcut === "media_pause") {
+                const playbackState = await this.readGlobalMediaPlaybackState();
+                if (playbackState !== "playing") {
+                    return {
+                        performed: false,
+                        reason: playbackState === "unknown"
+                            ? "O macOS nao confirmou nenhuma mídia tocando com segurança."
+                            : "Nenhuma mídia estava tocando no macOS.",
+                    };
+                }
+            }
+            if (normalizedShortcut === "media_resume" || normalizedShortcut === "media_play") {
+                const playbackState = await this.readGlobalMediaPlaybackState();
+                if (playbackState === "playing") {
+                    return {
+                        performed: false,
+                        reason: "Já havia mídia tocando no macOS.",
+                    };
+                }
+            }
             await this.triggerMacOSMediaTransport(mediaCommand);
-            return;
+            return { performed: true };
         }
         const namedKeyCodes = {
             return: 36,
@@ -1799,12 +2247,67 @@ end tell
                 "-e",
                 `tell application "System Events" to key code ${namedKeyCodes[key]}${usingClause}`,
             ]);
-            return;
+            return { performed: true };
         }
         await this.runCommand("osascript", [
             "-e",
             `tell application "System Events" to keystroke "${escapeAppleScript(key)}"${usingClause}`,
         ]);
+        return { performed: true };
+    }
+    async readGlobalMediaPlaybackState() {
+        const swiftScript = `
+import Foundation
+import Dispatch
+import Darwin
+
+typealias MRMediaRemoteGetNowPlayingApplicationIsPlayingFunction = @convention(c) (DispatchQueue, @escaping (Bool) -> Void) -> Void
+
+guard let handle = dlopen("/System/Library/PrivateFrameworks/MediaRemote.framework/MediaRemote", RTLD_NOW) else {
+  print("unknown")
+  exit(0)
+}
+
+guard let symbol = dlsym(handle, "MRMediaRemoteGetNowPlayingApplicationIsPlaying") else {
+  print("unknown")
+  exit(0)
+}
+
+let fn = unsafeBitCast(symbol, to: MRMediaRemoteGetNowPlayingApplicationIsPlayingFunction.self)
+let semaphore = DispatchSemaphore(value: 0)
+var isPlaying: Bool? = nil
+
+fn(DispatchQueue.global()) { value in
+  isPlaying = value
+  semaphore.signal()
+}
+
+if semaphore.wait(timeout: .now() + .milliseconds(800)) == .timedOut {
+  print("unknown")
+  exit(0)
+}
+
+print(isPlaying == true ? "playing" : "not_playing")
+`;
+        try {
+            const { stdout } = await this.runCommandCapture("swift", [
+                "-module-cache-path",
+                path.join(os.tmpdir(), "otto-bridge-swift-modcache"),
+                "-e",
+                swiftScript,
+            ]);
+            const state = normalizeText(stdout || "").trim();
+            if (state.includes("not_playing")) {
+                return "not_playing";
+            }
+            if (state.includes("playing")) {
+                return "playing";
+            }
+            return "unknown";
+        }
+        catch {
+            return "unknown";
+        }
     }
     async triggerMacOSMediaTransport(command) {
         const keyTypeMap = {
@@ -2664,42 +3167,7 @@ return { messages: messages.slice(-maxMessages) };
         }
         const baseline = Array.isArray(previousMessages) ? previousMessages : [];
         const chat = await this.readWhatsAppVisibleConversation("Contato", Math.max(8, baseline.length + 2));
-        if (!chat.messages.length) {
-            return {
-                ok: false,
-                reason: "Nao consegui ler as mensagens visiveis apos o envio no WhatsApp.",
-            };
-        }
-        const normalizedExpected = normalizeText(expectedText).slice(0, 120);
-        const normalizeMessage = (item) => `${normalizeText(item.author)}|${normalizeText(item.text)}`;
-        const beforeSignature = baseline.map(normalizeMessage).join("\n");
-        const afterSignature = chat.messages.map(normalizeMessage).join("\n");
-        const changed = beforeSignature !== afterSignature;
-        const beforeMatches = baseline.filter((item) => normalizeText(item.text).includes(normalizedExpected)).length;
-        const afterMatches = chat.messages.filter((item) => normalizeText(item.text).includes(normalizedExpected)).length;
-        const latest = chat.messages[chat.messages.length - 1] || null;
-        const latestAuthor = normalizeText(latest?.author || "");
-        const latestText = normalizeText(latest?.text || "");
-        const latestMatches = latestText.includes(normalizedExpected) && (latestAuthor === "voce" || latestAuthor === "você");
-        if ((changed && latestMatches) || (changed && afterMatches > beforeMatches)) {
-            return { ok: true, reason: "" };
-        }
-        if (!changed) {
-            return {
-                ok: false,
-                reason: "O WhatsApp nao mostrou mudanca visivel na conversa depois da tentativa de envio.",
-            };
-        }
-        if (afterMatches <= beforeMatches) {
-            return {
-                ok: false,
-                reason: "A conversa mudou, mas nao apareceu uma nova mensagem com o texto esperado no WhatsApp.",
-            };
-        }
-        return {
-            ok: false,
-            reason: "Nao consegui confirmar visualmente a nova mensagem enviada no WhatsApp.",
-        };
+        return verifyExpectedWhatsAppMessage(expectedText, baseline, chat.messages);
     }
     async takeScreenshot(targetPath) {
         const artifactsDir = path.join(os.homedir(), ".otto-bridge", "artifacts");
@@ -2889,6 +3357,14 @@ const wantsNext = /\\b(proxim[ao]?|next|skip|pular|avanca|avancar)\\b/.test(norm
 const wantsPrevious = /\\b(anterior|previous|volta[ar]?|back|retorna[ar]?)\\b/.test(normalizedDescription);
 const wantsPause = /\\b(pausa|pause|pausar)\\b/.test(normalizedDescription);
 const wantsResume = /\\b(retoma|retomar|resume|continu[ae]r|despausa|play)\\b/.test(normalizedDescription);
+const wantsSpotifyTrackPageOpen = location.hostname.includes("open.spotify.com")
+  && /\\bspotify\\b/.test(normalizedDescription)
+  && /\\b(pagina|titulo|nome|link)\\b/.test(normalizedDescription)
+  && /\\b(faixa|musica|track)\\b/.test(normalizedDescription);
+const wantsSpotifyTrackPagePlay = location.hostname.includes("open.spotify.com")
+  && /\\bspotify\\b/.test(normalizedDescription)
+  && /\\b(play|reproduzir|tocar|verde|principal)\\b/.test(normalizedDescription)
+  && /\\b(pagina|faixa|musica|track)\\b/.test(normalizedDescription);
 const stopWords = new Set([
   "o", "a", "os", "as", "um", "uma", "uns", "umas", "de", "da", "do", "das", "dos",
   "em", "no", "na", "nos", "nas", "para", "por", "com", "que", "visivel", "visiveis",
@@ -2998,6 +3474,33 @@ function clickElement(element, strategy, matchedText, matchedHref, score, totalC
   };
 }
 
+function pickYouTubeMusicPrimaryCard(element) {
+  let current = element instanceof Element ? element : null;
+  let best = null;
+  let bestScore = -Infinity;
+  while (current && current instanceof HTMLElement && current !== document.body) {
+    const rect = current.getBoundingClientRect();
+    const text = normalize(deriveText(current));
+    let score = 0;
+    if (rect.width >= window.innerWidth * 0.32) score += 40;
+    if (rect.width >= window.innerWidth * 0.42) score += 80;
+    if (rect.left <= window.innerWidth * 0.18) score += 90;
+    if ((rect.left + rect.width) <= window.innerWidth * 0.68) score += 120;
+    if (rect.top <= window.innerHeight * 0.7) score += 40;
+    if (text.includes("mais do youtube")) score -= 260;
+    if (text.includes("playlist")) score -= 40;
+    if (text.includes("podcast")) score -= 40;
+    if (text.includes("musica")) score += 28;
+    if (text.includes("video")) score -= 18;
+    if (score > bestScore) {
+      bestScore = score;
+      best = current;
+    }
+    current = current.parentElement;
+  }
+  return best;
+}
+
 function attemptYouTubeMusicTransportClick() {
   if (!isYouTubeMusic || !(wantsNext || wantsPrevious || wantsPause || wantsResume)) {
     return null;
@@ -3045,6 +3548,97 @@ function attemptYouTubeMusicSearchResultClick() {
     return null;
   }
 
+  const primaryCardButtons = Array.from(document.querySelectorAll("button, [role='button'], a[href*='watch?v=']"))
+    .filter((node) => node instanceof HTMLElement || node instanceof HTMLAnchorElement)
+    .filter((node) => isVisible(node))
+    .filter((node) => !(node.closest("ytmusic-player-bar")))
+    .map((node) => {
+      const element = node;
+      const rect = element.getBoundingClientRect();
+      const primaryCard = pickYouTubeMusicPrimaryCard(element);
+      const primaryCardRect = primaryCard ? primaryCard.getBoundingClientRect() : rect;
+      const label = normalize([
+        deriveText(element),
+        element.getAttribute("aria-label"),
+        element.getAttribute("title"),
+      ].filter(Boolean).join(" "));
+      const cardText = normalize(primaryCard ? deriveText(primaryCard) : deriveText(element.parentElement || element));
+      const isPlayButton = /\b(play|reproduzir|tocar)\b/.test(label);
+      const buttonCenterX = rect.left + (rect.width / 2);
+      const cardCenterX = primaryCardRect.left + (primaryCardRect.width / 2);
+      let score = 0;
+
+      if (!isPlayButton) {
+        return null;
+      }
+      if (buttonCenterX > (window.innerWidth * 0.44)) {
+        return null;
+      }
+      if (rect.width < 110 || rect.height < 36) {
+        return null;
+      }
+      if (primaryCardRect.left > (window.innerWidth * 0.16)) {
+        return null;
+      }
+      if (cardCenterX > (window.innerWidth * 0.36)) {
+        return null;
+      }
+      if (primaryCardRect.width < (window.innerWidth * 0.28)) {
+        return null;
+      }
+
+      for (const phrase of quotedPhrases) {
+        if (!phrase) continue;
+        if (cardText.includes(phrase) || label.includes(phrase)) score += 220;
+      }
+
+      for (const token of tokens) {
+        if (cardText.includes(token)) score += 30;
+        else if (label.includes(token)) score += 16;
+      }
+
+      if (tokens.length > 1) {
+        const matchCount = tokens.filter((token) => cardText.includes(token)).length;
+        if (matchCount >= Math.max(2, Math.ceil(tokens.length * 0.5))) score += 120;
+        if (matchCount === tokens.length) score += 80;
+      }
+
+      if ((primaryCardRect.left + (primaryCardRect.width / 2)) < (window.innerWidth * 0.48)) score += 320;
+      if (primaryCardRect.left <= window.innerWidth * 0.18) score += 140;
+      if (primaryCardRect.width >= window.innerWidth * 0.38) score += 120;
+      if ((primaryCardRect.left + primaryCardRect.width) <= window.innerWidth * 0.7) score += 160;
+      if (buttonCenterX < (window.innerWidth * 0.34)) score += 220;
+      if (buttonCenterX < (window.innerWidth * 0.4)) score += 120;
+      if (rect.top < (window.innerHeight * 0.7)) score += 90;
+      if (rect.width >= 120) score += 36;
+      if (rect.height >= 44) score += 18;
+      if (cardText.includes("mais do youtube")) score -= 320;
+      if (primaryCardRect.left > window.innerWidth * 0.45) score -= 260;
+      if (buttonCenterX > window.innerWidth * 0.42) score -= 360;
+      score += Math.max(0, 40 - Math.round(rect.top / 20));
+
+      return score > 0 ? {
+        node: element,
+        score,
+        label,
+        matchedText: primaryCard ? deriveText(primaryCard) : deriveText(element),
+      } : null;
+    })
+    .filter(Boolean)
+    .sort((left, right) => right.score - left.score);
+
+  if (primaryCardButtons.length) {
+    const winner = primaryCardButtons[0];
+    return clickElement(
+      winner.node,
+      "safari_dom_ytmusic_primary_card",
+      winner.matchedText || winner.label,
+      "",
+      winner.score,
+      primaryCardButtons.length,
+    );
+  }
+
   const rows = Array.from(document.querySelectorAll("ytmusic-responsive-list-item-renderer"))
     .filter((node) => node instanceof HTMLElement)
     .filter((node) => isVisible(node));
@@ -3137,6 +3731,215 @@ if (ytmResult) {
   return ytmResult;
 }
 
+function attemptSpotifyTrackPagePlayClick() {
+  if (!location.hostname.includes("open.spotify.com")) {
+    return null;
+  }
+  if (!location.pathname.includes("/track/")) {
+    return null;
+  }
+
+  const rankedButtons = Array.from(document.querySelectorAll(
+    "main [data-testid='play-button'], main button[aria-label], main button[title], [data-testid='entityHeader'] button, main button"
+  ))
+    .filter((node) => node instanceof HTMLElement)
+    .filter((node) => isVisible(node))
+    .filter((node) => !(node.closest("footer")))
+    .map((node, index) => {
+      const rect = node.getBoundingClientRect();
+      const label = normalize([
+        deriveText(node),
+        node.getAttribute("aria-label"),
+        node.getAttribute("title"),
+        node.getAttribute("data-testid"),
+      ].filter(Boolean).join(" "));
+      const background = normalize(window.getComputedStyle(node).backgroundColor || "");
+      let score = 0;
+
+      if (!/play|tocar|reproduzir/.test(label)) {
+        return null;
+      }
+
+      if (node.getAttribute("data-testid") === "play-button") score += 220;
+      if (label.includes("play")) score += 100;
+      if (background.includes("29, 185, 84") || background.includes("30, 215, 96")) score += 180;
+      if (rect.top <= window.innerHeight * 0.72) score += 90;
+      if (rect.top <= window.innerHeight * 0.56) score += 70;
+      if (rect.left <= window.innerWidth * 0.4) score += 80;
+      if (rect.width >= 44) score += 30;
+      if (rect.height >= 44) score += 30;
+      if (node.closest("[data-testid='entityHeader'], main")) score += 60;
+      score += Math.max(0, 18 - index);
+
+      return score > 0 ? { node, label, score } : null;
+    })
+    .filter(Boolean)
+    .sort((left, right) => right.score - left.score);
+
+  if (!rankedButtons.length) {
+    return null;
+  }
+
+  const winner = rankedButtons[0];
+  return clickElement(
+    winner.node,
+    "safari_dom_spotify_track_page_play",
+    winner.label,
+    location.href || "",
+    winner.score,
+    rankedButtons.length,
+  );
+}
+
+const spotifyTrackPagePlay = attemptSpotifyTrackPagePlayClick();
+if (spotifyTrackPagePlay) {
+  return spotifyTrackPagePlay;
+}
+
+function attemptSpotifySearchResultClick() {
+  if (!location.hostname.includes("open.spotify.com")) {
+    return null;
+  }
+  if (!quotedPhrases.length && !tokens.length) {
+    return null;
+  }
+
+  const rows = Array.from(document.querySelectorAll(
+    "[data-testid='tracklist-row'], [role='row']"
+  ))
+    .filter((node) => node instanceof HTMLElement)
+    .filter((node) => isVisible(node));
+
+  const rankedRows = rows
+    .map((row, index) => {
+      const titleNode = row.querySelector(
+        "[data-testid='internal-track-link'], a[href*='/track/'], [aria-colindex='2'] a[href*='/track/']"
+      );
+      const navigationTarget = titleNode instanceof HTMLAnchorElement || titleNode instanceof HTMLElement
+        ? titleNode
+        : null;
+      const titleText = String((titleNode && titleNode.textContent) || "").trim();
+      const rowText = deriveText(row);
+      const normalizedTitle = normalize(titleText);
+      const normalizedRow = normalize(rowText);
+      let score = 0;
+
+      for (const phrase of quotedPhrases) {
+        if (!phrase) continue;
+        if (normalizedTitle.includes(phrase)) score += 180;
+        else if (normalizedRow.includes(phrase)) score += 110;
+      }
+
+      for (const token of tokens) {
+        if (normalizedTitle.includes(token)) score += 26;
+        else if (normalizedRow.includes(token)) score += 10;
+      }
+
+      const titleMatches = tokens.filter((token) => normalizedTitle.includes(token)).length;
+      if (tokens.length > 1 && titleMatches >= Math.max(2, Math.ceil(tokens.length * 0.5))) score += 90;
+      if (titleMatches === tokens.length && tokens.length > 0) score += 70;
+      if (index < 4) score += Math.max(0, 24 - (index * 5));
+
+      const playCandidate = Array.from(row.querySelectorAll("button, [role='button'], a[href*='/track/']"))
+        .filter((candidate) => candidate instanceof HTMLElement || candidate instanceof HTMLAnchorElement)
+        .filter((candidate) => isVisible(candidate))
+        .map((candidate) => {
+          const label = normalize([
+            deriveText(candidate),
+            candidate.getAttribute("aria-label"),
+            candidate.getAttribute("title"),
+          ].filter(Boolean).join(" "));
+          let candidateScore = 0;
+          if (/play|tocar|reproduzir/.test(label)) candidateScore += 40;
+          if (candidate instanceof HTMLAnchorElement && normalize(candidate.href).includes("/track/")) candidateScore += 18;
+          return { candidate, candidateScore };
+        })
+        .sort((left, right) => right.candidateScore - left.candidateScore);
+
+      if (wantsSpotifyTrackPageOpen && !navigationTarget) {
+        return null;
+      }
+
+      return score > 0 ? {
+        row,
+        titleText,
+        href: titleNode instanceof HTMLAnchorElement ? titleNode.href : "",
+        score: score + (playCandidate[0]?.candidateScore || 0),
+        target: wantsSpotifyTrackPageOpen
+          ? navigationTarget
+          : (playCandidate[0]?.candidate || navigationTarget || row),
+      } : null;
+    })
+    .filter(Boolean)
+    .sort((left, right) => right.score - left.score);
+
+  if (!rankedRows.length) {
+    return null;
+  }
+
+  const winner = rankedRows[0];
+  const spotifyRow = winner.row instanceof HTMLElement ? winner.row : null;
+  const titleCandidate = spotifyRow?.querySelector(
+    "[data-testid='internal-track-link'], a[href*='/track/'], [aria-colindex='2'] a[href*='/track/']"
+  );
+  const explicitPlayButton = spotifyRow
+    ? Array.from(spotifyRow.querySelectorAll("button, [role='button']"))
+      .filter((node) => node instanceof HTMLElement)
+      .filter((node) => isVisible(node))
+      .find((node) => {
+        const label = normalize([
+          deriveText(node),
+          node.getAttribute("aria-label"),
+          node.getAttribute("title"),
+        ].filter(Boolean).join(" "));
+        return /\b(play|tocar|reproduzir)\b/.test(label);
+      })
+    : null;
+
+  const clickTarget = wantsSpotifyTrackPageOpen
+    ? (titleCandidate || winner.target)
+    : (explicitPlayButton || titleCandidate || winner.target);
+  const clicked = clickElement(
+    clickTarget,
+    wantsSpotifyTrackPageOpen
+      ? "safari_dom_spotify_track_link"
+      : (explicitPlayButton ? "safari_dom_spotify_play_button" : "safari_dom_spotify_result"),
+    winner.titleText || deriveText(winner.row),
+    winner.href || "",
+    winner.score,
+    rankedRows.length,
+  );
+  if (!clicked) {
+    return null;
+  }
+  if (spotifyRow instanceof HTMLElement && !explicitPlayButton && !wantsSpotifyTrackPageOpen) {
+    const rect = spotifyRow.getBoundingClientRect();
+    spotifyRow.dispatchEvent(new MouseEvent("dblclick", {
+      bubbles: true,
+      cancelable: true,
+      view: window,
+      clientX: rect.left + (rect.width / 2),
+      clientY: rect.top + (rect.height / 2),
+    }));
+  }
+  return clicked;
+}
+
+const spotifyResult = attemptSpotifySearchResultClick();
+if (spotifyResult) {
+  return spotifyResult;
+}
+
+if (location.hostname.includes("open.spotify.com") && (wantsSpotifyTrackPageOpen || wantsSpotifyTrackPagePlay)) {
+  return {
+    clicked: false,
+    reason: wantsSpotifyTrackPageOpen
+      ? "Nenhuma faixa visivel do Spotify Web combinou com a busca atual; nao vou clicar em abas, playlists ou albuns por fallback."
+      : "O Spotify Web nao mostrou um botao principal de reproduzir confiavel; nao vou clicar em elementos genericos por fallback.",
+    strategy: "safari_dom_spotify_no_fallback",
+  };
+}
+
 function scoreCandidate(element, rank) {
   const text = deriveText(element);
   const href = element instanceof HTMLAnchorElement
@@ -3257,7 +4060,7 @@ tell application "Safari"
   activate
   if (count of windows) = 0 then error "Safari nao possui janelas abertas."
   delay 1
-  set jsCode to "(function(){const title=document.title||'';const url=location.href||'';const text=((document.body&&document.body.innerText)||'').trim().slice(0,12000);const playerButton=document.querySelector('ytmusic-player-bar #play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button#play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button.play-pause-button');const playerTitle=(Array.from(document.querySelectorAll('ytmusic-player-bar .title, ytmusic-player-bar .content-info-wrapper .title, ytmusic-player-bar [slot=title]')).map((node)=>((node&&node.textContent)||'').trim()).find(Boolean))||'';const playerState=(playerButton&&((playerButton.getAttribute('title')||playerButton.getAttribute('aria-label')||playerButton.textContent)||'').trim())||'';return JSON.stringify({title,url,text,playerTitle,playerState});})();"
+  set jsCode to "(function(){const title=document.title||'';const url=location.href||'';const text=((document.body&&document.body.innerText)||'').trim().slice(0,12000);const isYouTubeMusic=location.hostname.includes('music.youtube.com');const isSpotify=location.hostname.includes('open.spotify.com');let playerButton=null;let playerTitle='';let playerState='';if(isYouTubeMusic){playerButton=document.querySelector('ytmusic-player-bar #play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button#play-pause-button, ytmusic-player-bar tp-yt-paper-icon-button.play-pause-button');playerTitle=(Array.from(document.querySelectorAll('ytmusic-player-bar .title, ytmusic-player-bar .content-info-wrapper .title, ytmusic-player-bar [slot=title]')).map((node)=>((node&&node.textContent)||'').trim()).find(Boolean))||'';playerState=(playerButton&&((playerButton.getAttribute('title')||playerButton.getAttribute('aria-label')||playerButton.textContent)||'').trim())||'';}else if(isSpotify){const visible=(node)=>{if(!(node instanceof Element))return false;const rect=node.getBoundingClientRect();if(rect.width<4||rect.height<4)return false;const style=window.getComputedStyle(node);if(style.visibility==='hidden'||style.display==='none'||Number(style.opacity||'1')===0)return false;return rect.bottom>=0&&rect.right>=0&&rect.top<=window.innerHeight&&rect.left<=window.innerWidth;};const spotifyTitleCandidates=Array.from(document.querySelectorAll(\"[data-testid='nowplaying-track-link'], footer a[href*='/track/'], [data-testid='now-playing-widget'] a[href*='/track/'], a[href*='/track/']\")).filter((node)=>visible(node)).map((node)=>({node,text:((node&&node.textContent)||'').trim(),rect:node.getBoundingClientRect()})).filter((entry)=>entry.text).sort((left,right)=>{const leftBottomBias=(left.rect.top>=window.innerHeight*0.72?200:0)+(left.rect.left<=window.innerWidth*0.45?120:0)+left.rect.top;const rightBottomBias=(right.rect.top>=window.innerHeight*0.72?200:0)+(right.rect.left<=window.innerWidth*0.45?120:0)+right.rect.top;return rightBottomBias-leftBottomBias;});playerTitle=(spotifyTitleCandidates[0]&&spotifyTitleCandidates[0].text)||'';playerButton=Array.from(document.querySelectorAll(\"footer button, [data-testid='control-button-playpause'], button[aria-label], button[title]\")).filter((node)=>visible(node)).map((node)=>({node,label:((node.getAttribute('aria-label')||node.getAttribute('title')||node.textContent)||'').trim(),rect:node.getBoundingClientRect()})).filter((entry)=>/play|pause|tocar|pausar|reproduzir/i.test(entry.label)).sort((left,right)=>{const leftScore=(left.rect.top>=window.innerHeight*0.72?200:0)+Math.max(0,200-Math.abs((left.rect.left+left.rect.width/2)-(window.innerWidth/2)));const rightScore=(right.rect.top>=window.innerHeight*0.72?200:0)+Math.max(0,200-Math.abs((right.rect.left+right.rect.width/2)-(window.innerWidth/2)));return rightScore-leftScore;})[0]?.node||null;playerState=(playerButton&&((playerButton.getAttribute('aria-label')||playerButton.getAttribute('title')||playerButton.textContent)||'').trim())||'';}return JSON.stringify({title,url,text,playerTitle,playerState});})();"
   set pageJson to do JavaScript jsCode in current tab of front window
 end tell
 return pageJson