aibroker 0.6.4 → 0.7.0

package/dist/adapters/pailot/gateway.js

@@ -13,7 +13,8 @@
 import { WebSocketServer, WebSocket } from "ws";
 import { join } from "node:path";
 import { writeFileSync, readFileSync, existsSync, unlinkSync, appendFileSync } from "node:fs";
-import { tmpdir, homedir } from "node:os";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
 const DEBUG_LOG = process.env.PAILOT_DEBUG ? "/tmp/pailot-ws-debug.log" : null;
 function dbg(msg) {
     if (DEBUG_LOG)
@@ -29,6 +30,7 @@ import { setItermSessionVar, setItermTabName, setItermBadge, killSession, create
 import { listPaiProjects, launchPaiProject } from "../../daemon/pai-projects.js";
 import { runAppleScript, sendKeystrokeToSession, sendEscapeSequenceToSession, pasteTextIntoSession, snapshotAllSessions } from "../iterm/core.js";
 import { hybridManager } from "../../core/hybrid.js";
+import { mqttPublishText, mqttPublishVoice, mqttPublishImage, mqttPublishTyping, mqttPublishScreenshot, mqttPublishSessions, mqttPublishTranscript, mqttPublishStatus as mqttPubStatus, mqttPublishControl, isMqttRunning, } from "./mqtt-broker.js";
 const WS_PORT = parseInt(process.env.PAILOT_PORT ?? "8765", 10);
 // --- State ---
 let wss = null;
@@ -48,126 +50,56 @@ const clientActiveSession = new Map();
 const clientLastActive = new Map();
 /** Consider a client "alive" if it responded within this window. */
 const CLIENT_ALIVE_THRESHOLD = 90_000; // 90s (3x the 30s heartbeat)
-// --- Per-session message outbox for offline/backgrounded clients ---
-// Buffers messages when no live client can receive them.
-// Stored per-session so drain delivers to the correct session.
-const MAX_OUTBOX_PER_SESSION = 50;
-const OUTBOX_DIR = join(homedir(), ".aibroker", "outbox");
-const outboxMap = new Map(); // sessionId → entries
-let missedImageCount = 0;
-function addToOutbox(msg) {
+// --- Sequence-based message log ---
+// Every broadcast message gets a monotonic sequence number. The log is a circular
+// buffer of the last N messages. Clients track their lastSeq and request catch_up
+// on connect or foreground resume. This replaces the old outbox system entirely —
+// no per-client state, fully idempotent, works regardless of reconnection path.
+const MESSAGE_LOG_SIZE = 200;
+let nextSeq = 1;
+const messageLog = [];
+/** Append a message to the log with a sequence number. Returns the seq (0 for ephemeral). */
+function appendToLog(msg) {
     const type = msg.type;
-    if (type === "typing")
-        return;
-    if (type === "image") {
-        missedImageCount++;
-        return;
-    }
-    const sessionId = msg.sessionId || "_global";
-    let queue = outboxMap.get(sessionId);
-    if (!queue) {
-        queue = [];
-        outboxMap.set(sessionId, queue);
-    }
-    queue.push({ msg, timestamp: Date.now() });
-    if (queue.length > MAX_OUTBOX_PER_SESSION)
-        queue.shift();
-    // Persist to disk (best-effort, async)
-    persistOutbox();
+    // Don't log ephemeral/meta messages
+    if (type === "typing" || type === "pong" || type === "sessions"
+        || type === "session_switched" || type === "unread" || type === "status")
+        return 0;
+    const seq = nextSeq++;
+    messageLog.push({ seq, msg: { ...msg, seq }, timestamp: Date.now() });
+    if (messageLog.length > MESSAGE_LOG_SIZE)
+        messageLog.shift();
+    return seq;
+}
+/** Return all log entries with seq > afterSeq, optionally filtered by session. */
+function getMessagesAfter(afterSeq, sessionId) {
+    return messageLog.filter(e => {
+        if (e.seq <= afterSeq)
+            return false;
+        // Session filter: if client has a session and message has a different one, skip
+        const msgSession = e.msg.sessionId;
+        if (sessionId && msgSession && msgSession !== sessionId)
+            return false;
+        return true;
+    });
 }
-function drainOutbox(ws) {
-    // Determine which session this client is currently viewing.
-    // Only drain messages that match the client's session or have no session ID.
+/** Handle catch_up command: replay missed messages to the client. */
+function handleCatchUp(ws, args) {
+    const lastSeq = typeof args?.lastSeq === "number" ? args.lastSeq : 0;
     const clientSession = clientActiveSession.get(ws);
-    // Collect entries eligible for this client, leaving non-matching entries in place.
-    const eligibleEntries = [];
-    const remainingMap = new Map();
-    for (const [sessionKey, entries] of outboxMap.entries()) {
-        const eligible = [];
-        const remaining = [];
-        for (const e of entries) {
-            const msgSession = e.msg.sessionId;
-            // Drain if: message has no session, client has no session, or sessions match
-            if (!msgSession || !clientSession || msgSession === clientSession) {
-                eligible.push(e);
-            }
-            else {
-                remaining.push(e);
-            }
-        }
-        eligibleEntries.push(...eligible);
-        if (remaining.length > 0)
-            remainingMap.set(sessionKey, remaining);
-    }
-    if (eligibleEntries.length === 0 && missedImageCount === 0)
+    const missed = getMessagesAfter(lastSeq, clientSession);
+    const currentSeq = nextSeq - 1;
+    if (missed.length === 0) {
+        // Still send response so client can update its epoch/seq tracking
+        sendTo(ws, { type: "catch_up", messages: [], serverSeq: currentSeq });
         return;
-    let textCount = 0;
-    let voiceCount = 0;
-    for (const e of eligibleEntries) {
-        const t = e.msg.type;
-        if (t === "text")
-            textCount++;
-        else if (t === "voice")
-            voiceCount++;
     }
-    const otherCount = eligibleEntries.length - textCount - voiceCount;
-    const parts = [];
-    if (textCount > 0)
-        parts.push(`${textCount} text message(s)`);
-    if (voiceCount > 0)
-        parts.push(`${voiceCount} voice note(s)`);
-    if (missedImageCount > 0)
-        parts.push(`${missedImageCount} image(s)`);
-    if (otherCount > 0)
-        parts.push(`${otherCount} other`);
+    log(`[PAILot] catch_up: replaying ${missed.length} messages (client lastSeq=${lastSeq}, server seq=${currentSeq})`);
     sendTo(ws, {
-        type: "text",
-        content: `📬 While you were away: ${parts.join(", ")}`,
+        type: "catch_up",
+        messages: missed.map(e => e.msg),
+        serverSeq: currentSeq,
     });
-    // Replay eligible buffered messages sorted by timestamp
-    eligibleEntries.sort((a, b) => a.timestamp - b.timestamp);
-    for (const entry of eligibleEntries) {
-        sendTo(ws, entry.msg);
-    }
-    // Replace outbox with only the non-drained (session-mismatched) entries
-    outboxMap.clear();
-    for (const [k, v] of remainingMap)
-        outboxMap.set(k, v);
-    missedImageCount = 0;
-    persistOutbox();
-}
-/** Persist outbox to disk so daemon restarts don't lose messages. */
-function persistOutbox() {
-    try {
-        const { mkdirSync, writeFileSync: writeSync } = require("node:fs");
-        mkdirSync(OUTBOX_DIR, { recursive: true });
-        const data = {};
-        for (const [k, v] of outboxMap)
-            data[k] = v;
-        writeSync(join(OUTBOX_DIR, "pending.json"), JSON.stringify({ messages: data, missedImageCount }));
-    }
-    catch { /* best-effort */ }
-}
-/** Restore outbox from disk on startup. */
-function restoreOutbox() {
-    try {
-        const path = join(OUTBOX_DIR, "pending.json");
-        if (!existsSync(path))
-            return;
-        const raw = readFileSync(path, "utf-8");
-        const data = JSON.parse(raw);
-        if (data.messages) {
-            for (const [k, v] of Object.entries(data.messages)) {
-                outboxMap.set(k, v);
-            }
-        }
-        if (data.missedImageCount)
-            missedImageCount = data.missedImageCount;
-        log(`[PAILot] Restored ${outboxMap.size} outbox queue(s) from disk`);
-        // Clean up the file after restoring
-        unlinkSync(path);
-    }
-    catch { /* ignore */ }
 }
 function isClientAlive(ws) {
     if (ws.readyState !== WebSocket.OPEN)
@@ -209,7 +141,6 @@ function isClaudeRelated(snap) {
 function handleSyncCommand(ws, args) {
     if (!hybridManager) {
         handleSessionsCommand(ws);
-        drainOutbox(ws);
         return;
     }
     const clientActiveId = typeof args?.activeSessionId === "string" ? args.activeSessionId : undefined;
@@ -256,7 +187,6 @@ function handleSyncCommand(ws, args) {
             clientActiveSession.set(ws, clientActiveId);
             log(`[PAILot] sync: restored client session "${sessions[idx].name}" (${clientActiveId.slice(0, 8)}...)`);
             handleSessionsCommand(ws);
-            drainOutbox(ws);
             return;
         }
         // Client's session no longer exists in iTerm — fall through to iTerm focus
@@ -307,9 +237,8 @@ end tell`)?.trim() ?? "";
             log(`[PAILot] sync: no focused session found — defaulting to first session "${sessions[0].name}"`);
         }
     }
-    // Return sessions with updated active state, then drain buffered messages
+    // Return sessions with updated active state
     handleSessionsCommand(ws);
-    drainOutbox(ws);
 }
 function handleSessionsCommand(ws) {
     if (!hybridManager) {
@@ -354,6 +283,10 @@ function handleSessionsCommand(ws) {
     if (ws.readyState === WebSocket.OPEN) {
         ws.send(payload);
     }
+    // MQTT dual-publish session list (retained) — Phase 1
+    if (isMqttRunning()) {
+        mqttPublishSessions(sessions);
+    }
 }
 function handleSwitchCommand(ws, args) {
     const sessionIndex = args.index;
@@ -414,6 +347,15 @@ end tell`);
     clientActiveSession.set(ws, session.backendSessionId);
     sendTo(ws, { type: "session_switched", name: session.name, sessionId: session.backendSessionId });
     log(`[PAILot] switched to ${session.kind} session "${session.name}" (${session.id})`);
+    // MQTT dual-publish control response (Phase 1)
+    if (isMqttRunning()) {
+        mqttPublishControl({ type: "session_switched", sessionId: session.backendSessionId, name: session.name });
+    }
+    // Auto-drain: replay any messages for the new session that were skipped while
+    // the client was viewing a different session. Uses lastSeq=0 which is safe
+    // because getMessagesAfter filters by sessionId — only messages for this
+    // session are returned. The client deduplicates via seenSeqsRef.
+    handleCatchUp(ws, { lastSeq: 0 });
 }
 function handleRenameCommand(ws, args) {
     const sessionId = args.sessionId;
@@ -434,6 +376,10 @@ function handleRenameCommand(ws, args) {
         }
     }
     sendTo(ws, { type: "session_renamed", sessionId, name });
+    // MQTT dual-publish control response (Phase 1)
+    if (isMqttRunning()) {
+        mqttPublishControl({ type: "session_renamed", sessionId, name });
+    }
     // Send updated sessions list so PAILot refreshes the header
     handleSessionsCommand(ws);
     log(`[PAILot] renamed session ${sessionId} to "${name}"`);
@@ -552,13 +498,23 @@ async function handleNavCommand(ws, args) {
     // sendKeystrokeToSession takes ASCII code: 13=enter, 9=tab, 27=escape
     // sendEscapeSequenceToSession takes ANSI direction char: A=up, B=down, C=right, D=left
     const keyMap = {
+        // Arrow keys (descriptive names)
         up: () => sendEscapeSequenceToSession(targetSession, "A"),
         down: () => sendEscapeSequenceToSession(targetSession, "B"),
         left: () => sendEscapeSequenceToSession(targetSession, "D"),
         right: () => sendEscapeSequenceToSession(targetSession, "C"),
+        // Vim-style arrow keys (Flutter nav screen sends these)
+        k: () => sendEscapeSequenceToSession(targetSession, "A"),
+        j: () => sendEscapeSequenceToSession(targetSession, "B"),
+        h: () => sendEscapeSequenceToSession(targetSession, "D"),
+        l: () => sendEscapeSequenceToSession(targetSession, "C"),
+        // Action keys
         enter: () => sendKeystrokeToSession(targetSession, 13),
+        Return: () => sendKeystrokeToSession(targetSession, 13),
         tab: () => sendKeystrokeToSession(targetSession, 9),
+        Tab: () => sendKeystrokeToSession(targetSession, 9),
         escape: () => sendKeystrokeToSession(targetSession, 27),
+        Escape: () => sendKeystrokeToSession(targetSession, 27),
         "ctrl-c": () => {
             // Send Ctrl+C (ETX, ASCII 3)
             runAppleScript(`tell application "iTerm2"
@@ -572,6 +528,20 @@ async function handleNavCommand(ws, args) {
       end repeat
     end repeat
   end repeat
+end tell`);
+        },
+        "ctrl+c": () => {
+            runAppleScript(`tell application "iTerm2"
+  repeat with w in windows
+    repeat with t in tabs of w
+      repeat with s in sessions of t
+        if id of s is "${targetSession}" then
+          tell s to write text (ASCII character 3)
+          return
+        end if
+      end repeat
+    end repeat
+  end repeat
 end tell`);
         },
     };
@@ -580,8 +550,10 @@ end tell`);
         action();
     }
     else {
-        // Fallback: send as literal text (vi keys like "dd", "0", "G", etc.)
-        pasteTextIntoSession(targetSession, key);
+        // Send each character individually (vi keys like "dd" need separate keystrokes)
+        for (const ch of key) {
+            pasteTextIntoSession(targetSession, ch);
+        }
     }
     log(`[PAILot] nav: sent ${key} to session ${targetSession.slice(0, 8)}...`);
     // Auto-screenshot after navigation key with a brief delay for render
@@ -590,11 +562,10 @@ end tell`);
         await triggerScreenshotForPailot();
     }
 }
-async function triggerScreenshotForPailot() {
+async function triggerScreenshotForPailot(sessionId) {
     if (!screenshotHandler)
         return;
-    // Only send to PAILot — this is triggered by PAILot commands
-    await screenshotHandler("pailot");
+    await screenshotHandler("pailot", sessionId);
 }
 // --- Helpers ---
 function sendTo(ws, msg) {
@@ -602,41 +573,60 @@ function sendTo(ws, msg) {
         ws.send(JSON.stringify(msg));
     }
 }
-function broadcast(msg, opts) {
-    // Only deliver to clients that have proven liveness recently.
-    // iOS can keep a WebSocket "open" while the app is backgrounded —
-    // ws.send() succeeds but the app never processes the data.
-    //
+function broadcast(msg, direct) {
+    // MQTT dual-publish typing indicators (Phase 1)
+    // Other message types are published by their specific broadcast* functions.
+    if (isMqttRunning() && msg.type === "typing") {
+        const sid = msg.sessionId;
+        if (sid)
+            mqttPublishTyping(sid, !!msg.typing);
+    }
+    // Append to message log FIRST — every non-ephemeral message gets a seq number.
+    // Clients that miss it will catch up via the catch_up command.
+    const seq = appendToLog(msg);
+    if (seq > 0)
+        msg = { ...msg, seq };
     // Session filtering: if the message carries a sessionId, only deliver to
     // clients viewing that session. This prevents cross-session content bleed.
-    // Exception: direct replies (pailot_send) skip the session gate — the user
-    // must see replies regardless of which session they're viewing.
+    // When a message is gated, notify live clients so they can show an unread badge.
+    // Exception: "direct" messages (explicit pailot_send replies) bypass the gate —
+    // the user expects to see responses from any session they interact with.
     const msgSessionId = msg.sessionId;
-    const applySessionGate = !opts?.skipSessionGate;
-    let delivered = false;
+    let delivered = 0;
     let skippedDead = 0;
     let skippedSession = 0;
+    const gatedClients = [];
     const payload = JSON.stringify(msg);
     for (const ws of clients) {
         if (!isClientAlive(ws)) {
             skippedDead++;
             continue;
         }
-        // Session gate: if both the message and client have a session, they must match
-        if (applySessionGate && msgSessionId) {
+        if (msgSessionId && !direct) {
             const clientSession = clientActiveSession.get(ws);
             if (clientSession && clientSession !== msgSessionId) {
                 skippedSession++;
+                gatedClients.push(ws);
                 continue;
             }
         }
         ws.send(payload);
-        delivered = true;
+        delivered++;
+    }
+    log(`[PAILot] broadcast type=${msg.type} seq=${seq} session=${msgSessionId ?? "none"}: delivered=${delivered} skippedDead=${skippedDead} skippedSession=${skippedSession}${direct ? " DIRECT" : ""}`);
+    // Debug: log payload for text messages to diagnose app-side rendering issues
+    if (msg.type === "text" && delivered > 0) {
+        log(`[PAILot] DEBUG payload: ${payload.slice(0, 200)}`);
     }
-    log(`[PAILot] broadcast type=${msg.type} session=${msgSessionId ?? "none"}: delivered=${delivered ? 1 : 0} skippedDead=${skippedDead} skippedSession=${skippedSession} outboxed=${!delivered}${opts?.skipSessionGate ? " (gate-bypass)" : ""}`);
-    // No live clients received the message — buffer for later
-    if (!delivered) {
-        addToOutbox(msg);
+    // Notify live clients viewing other sessions about unread messages
+    if (delivered === 0 && gatedClients.length > 0 && msg.type !== "typing") {
+        const unreadNotification = JSON.stringify({
+            type: "unread",
+            sessionId: msgSessionId,
+        });
+        for (const ws of gatedClients) {
+            ws.send(unreadNotification);
+        }
     }
 }
 // --- Voice message batching ---
@@ -648,6 +638,11 @@ let voiceBatchTranscripts = [];
 let voiceBatchOnMessage = null;
 /** iTerm session ID resolved when the first voice chunk of this batch arrived. */
 let voiceBatchSessionId = "";
+/** Set the voice batch session from external callers (MQTT path). */
+export function setVoiceBatchSession(sessionId) {
+    if (!voiceBatchSessionId)
+        voiceBatchSessionId = sessionId;
+}
 function flushVoiceBatch() {
     if (voiceBatchTranscripts.length === 0)
         return;
@@ -658,8 +653,8 @@ function flushVoiceBatch() {
     voiceBatchOnMessage = null;
     voiceBatchSessionId = "";
     voiceBatchTimer = null;
-    log(`[PAILot] Flushing voice batch (${combined.length} chars)`);
     const routeSession = batchSession || activeItermSessionId;
+    log(`[PAILot] Flushing voice batch (${combined.length} chars) → session=${routeSession?.slice(0, 8) ?? "none"} (batch=${batchSession?.slice(0, 8) ?? "none"}, active=${activeItermSessionId?.slice(0, 8) ?? "none"})`);
     if (routeSession) {
         pailotReplyMap.set(routeSession, routeSession);
         setLastRoutedSessionId(routeSession);
@@ -676,7 +671,7 @@ function flushVoiceBatch() {
 }
 // --- Voice transcription for PAILot ---
 const execFileAsync = promisify(execFile);
-async function transcribeAndRoute(audioBase64, onMessage, messageId) {
+export async function transcribeAndRoute(audioBase64, onMessage, messageId) {
     const base = `pailot-voice-${Date.now()}-${randomUUID().slice(0, 8)}`;
     const audioFile = join(tmpdir(), `${base}.m4a`);
     const filesToClean = [
@@ -714,6 +709,10 @@ async function transcribeAndRoute(audioBase64, onMessage, messageId) {
         // Reflect transcript back to the app so the voice bubble shows text
         if (messageId) {
             broadcast({ type: "transcript", messageId, content: transcript });
+            // MQTT dual-publish (Phase 1)
+            if (isMqttRunning()) {
+                mqttPublishTranscript(messageId, transcript);
+            }
         }
         // Batch: accumulate transcripts and reset the timer
         voiceBatchTranscripts.push(transcript);
@@ -741,8 +740,6 @@ async function transcribeAndRoute(audioBase64, onMessage, messageId) {
  */
 export function startWsGateway(onMessage) {
     wss = new WebSocketServer({ port: WS_PORT });
-    // Restore any buffered messages from a previous daemon run
-    restoreOutbox();
     // Server-side ping: keep connections alive and detect dead iOS clients.
     // iOS suspends backgrounded apps but keeps the TCP socket "open" — without
     // server pings, ws.readyState stays OPEN indefinitely even though the app is gone.
@@ -831,6 +828,9 @@ end tell`)?.trim() ?? "";
                         case "sync":
                             handleSyncCommand(ws, args);
                             return;
+                        case "catch_up":
+                            handleCatchUp(ws, args);
+                            return;
                         case "switch":
                             handleSwitchCommand(ws, args);
                             return;
@@ -905,15 +905,32 @@ end tell`)?.trim() ?? "";
                     });
                     return;
                 }
-                // Image message — save to temp file, route caption as text
-                // NOTE: Do NOT send the file path to Claude Code — it tries to read .jpg files
-                // as images, which corrupts the conversation context with unprocessable image data.
+                // Image message — save to temp file, convert HEIC→JPEG if needed, route caption as text
                 if (msg.type === "image" && msg.imageBase64) {
-                    const ext = (msg.mimeType ?? "image/jpeg").includes("png") ? "png" : "jpg";
-                    const imgPath = join(tmpdir(), `pailot-img-${Date.now()}-${randomUUID().slice(0, 8)}.${ext}`);
+                    const mime = (msg.mimeType ?? "image/jpeg").toLowerCase();
                     const imgBuf = Buffer.from(msg.imageBase64, "base64");
-                    writeFileSync(imgPath, imgBuf);
-                    log(`[PAILot] Image saved (${imgBuf.length} bytes) → ${imgPath}`);
+                    let imgPath;
+                    if (mime.includes("heic") || mime.includes("heif")) {
+                        // HEIC/HEIF: save with real extension, convert to JPEG via macOS sips
+                        const heicPath = join(tmpdir(), `pailot-img-${Date.now()}-${randomUUID().slice(0, 8)}.heic`);
+                        imgPath = heicPath.replace(/\.heic$/, ".jpg");
+                        writeFileSync(heicPath, imgBuf);
+                        try {
+                            execFileSync("sips", ["-s", "format", "jpeg", heicPath, "--out", imgPath], { timeout: 10000 });
+                            unlinkSync(heicPath);
+                            log(`[PAILot] HEIC→JPEG converted (${imgBuf.length} bytes) → ${imgPath}`);
+                        }
+                        catch (err) {
+                            log(`[PAILot] HEIC conversion failed: ${err}, keeping original`);
+                            imgPath = heicPath;
+                        }
+                    }
+                    else {
+                        const ext = mime.includes("png") ? "png" : "jpg";
+                        imgPath = join(tmpdir(), `pailot-img-${Date.now()}-${randomUUID().slice(0, 8)}.${ext}`);
+                        writeFileSync(imgPath, imgBuf);
+                        log(`[PAILot] Image saved (${imgBuf.length} bytes) → ${imgPath}`);
+                    }
                     const caption = msg.caption || "";
                     // Embed the path inside parentheses so Claude Code doesn't auto-attach
                     // the .jpg as an image (which corrupts the session if the API rejects it).
@@ -956,8 +973,8 @@ end tell`)?.trim() ?? "";
                     setMessageSource("whatsapp");
                 }
             }
-            catch {
-                log(`[PAILot] Invalid message from ${addr}`);
+            catch (parseErr) {
+                log(`[PAILot] Invalid message from ${addr}: ${parseErr instanceof Error ? parseErr.message : String(parseErr)} — raw: ${String(raw).slice(0, 300)}`);
             }
         });
         ws.on("close", () => {
@@ -972,9 +989,8 @@ end tell`)?.trim() ?? "";
             clientLastActive.delete(ws);
             clientActiveSession.delete(ws);
         });
-        // Welcome — outbox drains after client sends "sync" command
+        // Outbox drains after client sends "sync" command or next ping
         // (so activeSessionId is set before messages arrive)
-        sendTo(ws, { type: "text", content: "Connected to PAILot gateway." });
     });
     wss.on("error", (err) => {
         log(`WebSocket gateway error: ${err.message}`);
@@ -1003,19 +1019,25 @@ function resolveSessionId(sessionId) {
     // Last resort: ask hybrid manager for the active session's backend ID
     return hybridManager?.activeSession?.backendSessionId || undefined;
 }
-export function broadcastText(text, sessionId, opts) {
-    const resolvedSession = resolveSessionId(sessionId);
-    broadcast({ type: "typing", typing: false, ...(resolvedSession && { sessionId: resolvedSession }) }, opts);
-    broadcast({ type: "text", content: text, ...(resolvedSession && { sessionId: resolvedSession }) }, opts);
+export function broadcastText(text, sessionId, direct) {
+    const resolvedSession = sessionId || resolveSessionId(sessionId);
+    broadcast({ type: "typing", typing: false, ...(resolvedSession && { sessionId: resolvedSession }) }, direct);
+    broadcast({ type: "text", content: text, ...(resolvedSession && { sessionId: resolvedSession }) }, direct);
+    // MQTT publish — always publish when broker is running
+    if (isMqttRunning()) {
+        if (resolvedSession)
+            mqttPublishTyping(resolvedSession, false);
+        mqttPublishText(resolvedSession ?? "global", text);
+    }
 }
 /**
  * Broadcast a voice note to all connected PAILot clients.
  * Converts OGG Opus to M4A (AAC) since iOS can't play OGG natively.
  * @param sessionId — iTerm session ID of the originating Claude session
  */
-export async function broadcastVoice(audioBuffer, transcript, sessionId, opts) {
-    const resolvedSession = resolveSessionId(sessionId);
-    broadcast({ type: "typing", typing: false, ...(resolvedSession && { sessionId: resolvedSession }) }, opts);
+export async function broadcastVoice(audioBuffer, transcript, sessionId, direct) {
+    const resolvedSession = sessionId || resolveSessionId(sessionId);
+    broadcast({ type: "typing", typing: false, ...(resolvedSession && { sessionId: resolvedSession }) }, direct);
     let sendBuffer = audioBuffer;
     // Convert OGG Opus → M4A for iOS compatibility
     try {
@@ -1038,25 +1060,39 @@ export async function broadcastVoice(audioBuffer, transcript, sessionId, opts) {
     catch (err) {
         log(`[PAILot] OGG→M4A conversion failed, sending raw: ${err}`);
     }
+    const voiceBase64 = sendBuffer.toString("base64");
     broadcast({
         type: "voice",
         content: transcript,
-        audioBase64: sendBuffer.toString("base64"),
+        audioBase64: voiceBase64,
         ...(resolvedSession && { sessionId: resolvedSession }),
-    }, opts);
+    }, direct);
+    if (isMqttRunning()) {
+        if (resolvedSession)
+            mqttPublishTyping(resolvedSession, false);
+        mqttPublishVoice(resolvedSession ?? "global", voiceBase64, transcript);
+    }
 }
 /**
  * Broadcast a screenshot/image to all connected PAILot clients.
  * @param sessionId — iTerm session ID of the originating Claude session
  */
-export function broadcastImage(imageBuffer, caption, sessionId) {
-    const resolvedSession = resolveSessionId(sessionId);
+export function broadcastImage(imageBuffer, caption, sessionId, direct) {
+    const resolvedSession = sessionId || resolveSessionId(sessionId);
+    const imgBase64 = imageBuffer.toString("base64");
     broadcast({
         type: "image",
-        imageBase64: imageBuffer.toString("base64"),
+        imageBase64: imgBase64,
         caption: caption ?? "Screenshot",
         ...(resolvedSession && { sessionId: resolvedSession }),
-    });
+    }, direct);
+    if (isMqttRunning()) {
+        const target = resolvedSession ?? "global";
+        mqttPublishImage(target, imgBase64, caption ?? "Screenshot");
+        if ((caption ?? "Screenshot").toLowerCase().includes("screenshot")) {
+            mqttPublishScreenshot(target, imgBase64);
+        }
+    }
 }
 /**
  * Broadcast a status change to all connected PAILot clients.
@@ -1064,6 +1100,10 @@ export function broadcastImage(imageBuffer, caption, sessionId) {
  */
 export function broadcastStatus(status) {
     broadcast({ type: "status", status });
+    // MQTT dual-publish (Phase 1)
+    if (isMqttRunning()) {
+        mqttPubStatus(status);
+    }
 }
 /**
  * Returns true if any PAILot clients are connected.
@@ -1083,4 +1123,174 @@ export function stopWsGateway() {
         wss = null;
     }
 }
+/**
+ * Handle a command from MQTT (no WebSocket needed).
+ * Replicates the WS command dispatcher for MQTT-only clients.
+ */
+export function handleMqttCommand(command, args = {}) {
+    if (!hybridManager) {
+        log(`[MQTT] command ${command} — no hybridManager`);
+        return;
+    }
+    switch (command) {
+        case "sessions": {
+            // Prune dead sessions and publish current list via MQTT
+            const liveSnapshots = snapshotAllSessions();
+            const liveIds = new Set(liveSnapshots.map(s => s.id));
+            hybridManager.pruneDeadVisualSessions(liveIds);
+            const knownIds = new Set(hybridManager.listSessions().map(s => s.backendSessionId));
+            const seenTabs = new Set();
+            for (const snap of liveSnapshots) {
+                if (!isClaudeRelated(snap))
+                    continue;
+                const displayName = snap.tabTitle ?? snap.paiName ?? snap.name;
+                if (seenTabs.has(displayName))
+                    continue;
+                seenTabs.add(displayName);
+                if (!knownIds.has(snap.id)) {
+                    hybridManager.registerVisualSession(displayName, "", snap.id);
+                }
+                else {
+                    const existing = hybridManager.listSessions().find(s => s.backendSessionId === snap.id);
+                    if (existing && existing.name !== displayName)
+                        existing.name = displayName;
+                }
+            }
+            const active = hybridManager.activeSession;
+            const sessions = hybridManager.listSessions().map((s, i) => ({
+                index: i + 1,
+                name: s.name,
+                type: "claude",
+                kind: s.kind,
+                isActive: active ? s.id === active.id : false,
+                id: s.backendSessionId,
+            }));
+            mqttPublishSessions(sessions);
+            break;
+        }
+        case "sync": {
+            // Sync is sessions + set active from client preference
+            const clientActiveId = args.activeSessionId;
+            if (clientActiveId) {
+                const sessions = hybridManager.listSessions();
+                const idx = sessions.findIndex(s => s.backendSessionId === clientActiveId);
+                if (idx >= 0) {
+                    hybridManager.switchToIndex(idx + 1);
+                    setActiveItermSessionId(clientActiveId);
+                    setLastRoutedSessionId(clientActiveId);
+                }
+            }
+            handleMqttCommand("sessions");
+            break;
+        }
+        case "switch": {
+            const sessionId = args.sessionId;
+            const sessionIndex = args.index;
+            let targetIndex;
+            if (sessionIndex) {
+                targetIndex = sessionIndex;
+            }
+            else if (sessionId) {
+                const sessions = hybridManager.listSessions();
+                const idx = sessions.findIndex(s => s.backendSessionId === sessionId);
+                if (idx >= 0)
+                    targetIndex = idx + 1;
+            }
+            if (targetIndex) {
+                const session = hybridManager.switchToIndex(targetIndex);
+                if (session?.kind === "visual") {
+                    setActiveItermSessionId(session.backendSessionId);
+                }
+                setLastRoutedSessionId(session?.backendSessionId ?? "");
+                mqttPublishControl({ type: "session_switched", sessionId: session?.backendSessionId, name: session?.name });
+                handleMqttCommand("sessions");
+            }
+            break;
+        }
+        case "screenshot": {
+            const ssSessionId = args.sessionId;
+            log(`[MQTT] screenshot command: requested session=${ssSessionId?.slice(0, 8) ?? "none"}`);
+            if (ssSessionId) {
+                setActiveItermSessionId(ssSessionId);
+                setLastRoutedSessionId(ssSessionId);
+            }
+            triggerScreenshotForPailot(ssSessionId).catch((err) => {
+                log(`[MQTT] screenshot error: ${err}`);
+            });
+            break;
+        }
+        case "nav": {
+            handleNavCommand(null, args).catch((err) => {
+                log(`[MQTT] nav error: ${err}`);
+            });
+            break;
+        }
+        case "rename": {
+            const sessionId = args.sessionId;
+            const name = args.name;
+            if (sessionId && name) {
+                const sessions = hybridManager.listSessions();
+                const session = sessions.find(s => s.backendSessionId === sessionId);
+                if (session) {
+                    session.name = name;
+                    if (session.kind === "visual") {
+                        setItermSessionVar(sessionId, name);
+                        setItermTabName(sessionId, name);
+                        setItermBadge(sessionId, name);
+                    }
+                }
+                mqttPublishControl({ type: "session_renamed", sessionId, name });
+                handleMqttCommand("sessions");
+            }
+            break;
+        }
+        case "remove": {
+            const sessionId = args.sessionId;
+            if (sessionId) {
+                const sessions = hybridManager.listSessions();
+                const idx = sessions.findIndex(s => s.backendSessionId === sessionId);
+                if (idx >= 0) {
+                    const target = sessions[idx];
+                    if (target.kind === "visual" && target.backendSessionId) {
+                        killSession(target.backendSessionId);
+                    }
+                    hybridManager.removeByIndex(idx + 1);
+                }
+                handleMqttCommand("sessions");
+            }
+            break;
+        }
+        case "create": {
+            const path = args.path;
+            const command = path ? `cd ${path.replace(/"/g, '\\"')} && claude` : "claude";
+            const name = path ? path.split("/").filter(Boolean).pop() ?? "Claude" : "Claude";
+            const sessionId = createClaudeSession(command);
+            if (!sessionId) {
+                log("[MQTT] create: failed to create session");
+                break;
+            }
+            setItermSessionVar(sessionId, name);
+            setItermTabName(sessionId, name);
+            setItermBadge(sessionId, name);
+            hybridManager.registerVisualSession(name, "", sessionId);
+            const sessions = hybridManager.listSessions();
+            const idx = sessions.findIndex(s => s.backendSessionId === sessionId);
+            if (idx >= 0) {
+                hybridManager.switchToIndex(idx + 1);
+                setActiveItermSessionId(sessionId);
+                setLastRoutedSessionId(sessionId);
+            }
+            mqttPublishControl({ type: "session_switched", name, sessionId });
+            handleMqttCommand("sessions");
+            break;
+        }
+        case "catch_up": {
+            // MQTT handles delivery natively — just update the session list
+            handleMqttCommand("sessions");
+            break;
+        }
+        default:
+            log(`[MQTT] unknown command: ${command}`);
+    }
+}
 //# sourceMappingURL=gateway.js.map