u-foo 1.0.6 → 1.1.9

package/src/agent/ptyRunner.js

@@ -1,6 +1,9 @@
 const fs = require("fs");
 const path = require("path");
+const net = require("net");
+const { spawnSync } = require("child_process");
 const EventBus = require("../bus");
+const { PTY_SOCKET_MESSAGE_TYPES, PTY_SOCKET_SUBSCRIBE_MODES } = require("../shared/ptySocketContract");
 const { runInternalRunner } = require("./internalRunner");
 const { getUfooPaths } = require("../ufoo/paths");
 
@@ -87,15 +90,19 @@ function buildPrompt(text, marker) {
 }
 
 function resolveCommand(agentType) {
+  const normalizedAgent = String(agentType || "").trim().toLowerCase();
   const rawCmd = String(process.env.UFOO_PTY_CMD || "").trim();
   if (rawCmd) {
     const rawArgs = String(process.env.UFOO_PTY_ARGS || "").trim();
     const args = rawArgs ? rawArgs.split(/\s+/).filter(Boolean) : [];
     return { command: rawCmd, args };
   }
-  if (agentType === "claude" || agentType === "claude-code") {
+  if (normalizedAgent === "claude" || normalizedAgent === "claude-code") {
     return { command: "claude", args: [] };
   }
+  if (normalizedAgent === "ufoo" || normalizedAgent === "ucode" || normalizedAgent === "ufoo-code") {
+    return { command: "ucode", args: [] };
+  }
   return { command: "codex", args: ["--no-alt-screen", "--sandbox", "workspace-write"] };
 }
 
@@ -107,11 +114,23 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
   } catch {
     throw new Error("node-pty not installed");
   }
+  let Terminal = null;
+  let SerializeAddon = null;
+  try {
+    const xterm = await import("xterm-headless");
+    const serialize = await import("xterm-addon-serialize");
+    Terminal = xterm.Terminal || (xterm.default && xterm.default.Terminal);
+    SerializeAddon = serialize.SerializeAddon || (serialize.default && serialize.default.SerializeAddon);
+  } catch {
+    Terminal = null;
+    SerializeAddon = null;
+  }
   const { subscriber } = parseSubscriberId();
   const queueDir = path.join(getUfooPaths(projectRoot).busQueuesDir, safeSubscriber(subscriber));
   const queueFile = path.join(queueDir, "pending.jsonl");
   const runDir = getUfooPaths(projectRoot).runDir;
   const logFile = path.join(runDir, "pty-runner.log");
+  const injectSockPath = path.join(queueDir, "inject.sock");
 
   const { command, args } = resolveCommand(agentType);
   const env = {
@@ -124,6 +143,9 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
 
   let running = true;
   let busy = false;
+  let ptyAlive = false;
+  let ptyReady = false;
+  let readyTimer = null;
   let currentPublisher = "";
   let currentMarker = "";
   let pendingOutput = [];
@@ -131,19 +153,291 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
   let flushTimer = null;
   let idleTimer = null;
   let watchdogTimer = null;
+  let suppressEcho = false;
+  let echoMarker = "";
+  let suppressTimer = null;
   let fallbackInProgress = false;
   let ptyProcess = null;
+  let restartCount = 0;
+  let lastSpawnTime = 0;
+  const MAX_RESTARTS = 3;
+  const RESTART_STABLE_MS = 30000; // reset counter if process ran > 30s
+  const RESTART_DELAY_MS = 2000;
+  const READY_QUIET_MS = 3000; // TUI is "ready" after 3s of no output
   const messageQueue = [];
+  const injectServer = setupInjectServer();
+  initScreenBuffer(80, 24);
   const maxChunk = 2000;
-  const idleMs = 2000;
+  const idleMs = 30000;
   const watchdogMs = 120000;
   const maxQueue = 200;
   const watchdogAction = String(process.env.UFOO_PTY_WATCHDOG_ACTION || "restart").toLowerCase();
   let sendQueue = Promise.resolve();
+  const DROP_LINE_PATTERNS = [
+    /__UFOO_DONE_/,
+    /请在完成后输出以下标记/,
+    /context left/i,
+    /esc to interrupt/i,
+    /for shortcuts/i,
+    /Preparing to run session start commands/i,
+  ];
+
+  function shouldDropLine(line) {
+    if (!line) return true;
+    const trimmed = line.trim();
+    if (!trimmed) return true;
+    if (/^[›❯>]$/.test(trimmed)) return true;
+    return DROP_LINE_PATTERNS.some((re) => re.test(trimmed));
+  }
+
+  function sanitizeChunk(chunk) {
+    if (!chunk) return "";
+    let text = String(chunk);
+    if (text.includes("\r")) {
+      const parts = text.split("\r");
+      text = parts[parts.length - 1];
+    }
+    const lines = text.split("\n").filter((line) => !shouldDropLine(line));
+    return lines.join("\n");
+  }
 
   function enqueueSend(target, message) {
     if (!target || !message) return;
-    sendQueue = sendQueue.then(() => eventBus.send(target, message, subscriber)).catch(() => {});
+    sendQueue = sendQueue.then(() => eventBus.send(target, message, subscriber)).catch((err) => {
+      logNote(`[send-error] target=${target} err=${err.message || err}`);
+    });
+  }
+
+  // TTY view subscribers (same protocol as launcher inject.sock)
+  const outputSubscribers = new Set();
+  let term = null;
+  let serializeAddon = null;
+  let termWriteQueue = Promise.resolve();
+  const OUTPUT_RING_MAX = (() => {
+    const env = Number.parseInt(process.env.UFOO_INTERNAL_RING_MAX || "", 10);
+    if (Number.isFinite(env) && env > 0) return env;
+    return 512 * 1024;
+  })();
+  let outputRingBuffer = "";
+
+  function initScreenBuffer(cols = 80, rows = 24) {
+    if (!Terminal || !SerializeAddon) return null;
+    try {
+      const scrollbackEnv = Number.parseInt(process.env.UFOO_INTERNAL_SCROLLBACK || "", 10);
+      const scrollback = Number.isFinite(scrollbackEnv) && scrollbackEnv >= 0
+        ? scrollbackEnv
+        : 20000;
+      term = new Terminal({
+        cols,
+        rows,
+        scrollback,
+        allowProposedApi: true,
+        convertEol: true,
+      });
+      serializeAddon = new SerializeAddon();
+      term.loadAddon(serializeAddon);
+    } catch {
+      term = null;
+      serializeAddon = null;
+    }
+    return term;
+  }
+
+  function enqueueTermWrite(data) {
+    if (!term || !data) return;
+    termWriteQueue = termWriteQueue.then(() => new Promise((resolve) => {
+      term.write(data, resolve);
+    })).catch(() => {});
+  }
+
+  function serializeBuffer(buffer, scrollback) {
+    if (!term || !serializeAddon || !buffer) return "";
+    try {
+      if (typeof serializeAddon._serializeBuffer === "function") {
+        return serializeAddon._serializeBuffer(term, buffer, scrollback);
+      }
+      if (buffer === term.buffer.normal && typeof serializeAddon.serialize === "function") {
+        return serializeAddon.serialize({
+          scrollback,
+          excludeAltBuffer: true,
+          excludeModes: true,
+        });
+      }
+      return "";
+    } catch {
+      return "";
+    }
+  }
+
+  async function serializeSnapshot(mode = "full") {
+    if (!term || !serializeAddon) return null;
+    try {
+      await termWriteQueue;
+      const active = term.buffer.active;
+      const normal = term.buffer.normal;
+      const scrollback = term.options && Number.isFinite(term.options.scrollback)
+        ? term.options.scrollback
+        : undefined;
+
+      if (mode === "screen") {
+        const screen = serializeBuffer(active, 0);
+        return screen ? { data: screen } : null;
+      }
+
+      let data = serializeBuffer(normal, scrollback);
+      if (active && active !== normal) {
+        const alt = serializeBuffer(active, 0);
+        if (alt) data += `\x1b[H${alt}`;
+      }
+      return data ? { data } : null;
+    } catch {
+      return null;
+    }
+  }
+
+  function broadcastOutput(data) {
+    const text = Buffer.from(data || "").toString("utf8");
+    if (!text) return;
+    enqueueTermWrite(text);
+    outputRingBuffer += text;
+    if (outputRingBuffer.length > OUTPUT_RING_MAX) {
+      outputRingBuffer = outputRingBuffer.slice(-OUTPUT_RING_MAX);
+    }
+    if (outputSubscribers.size === 0) return;
+    const msg = JSON.stringify({ type: PTY_SOCKET_MESSAGE_TYPES.OUTPUT, data: text, encoding: "utf8" }) + "\n";
+    for (const sub of outputSubscribers) {
+      try {
+        sub.write(msg);
+      } catch {
+        outputSubscribers.delete(sub);
+      }
+    }
+  }
+
+  function setupInjectServer() {
+    const dir = path.dirname(injectSockPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    if (fs.existsSync(injectSockPath)) {
+      try { fs.unlinkSync(injectSockPath); } catch { /* ignore */ }
+    }
+    const server = net.createServer((client) => {
+      let buffer = "";
+      client.on("data", (data) => {
+        buffer += data.toString("utf8");
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const req = JSON.parse(line);
+            if (req.type === "inject" && req.command) {
+              if (ptyProcess && ptyAlive) {
+                ptyProcess.write(String(req.command));
+                setTimeout(() => {
+                  if (!ptyProcess || !ptyAlive) return;
+                  ptyProcess.write("\x1b");
+                  setTimeout(() => {
+                    if (ptyProcess && ptyAlive) {
+                      ptyProcess.write("\r");
+                    }
+                  }, 100);
+                }, 200);
+                client.write(JSON.stringify({ ok: true }) + "\n");
+              } else {
+                client.write(JSON.stringify({ ok: false, error: "pty not ready" }) + "\n");
+              }
+            } else if (req.type === PTY_SOCKET_MESSAGE_TYPES.RAW && typeof req.data === "string") {
+              if (ptyProcess && ptyAlive) {
+                ptyProcess.write(req.data);
+                client.write(JSON.stringify({ ok: true }) + "\n");
+              } else {
+                client.write(JSON.stringify({ ok: false, error: "pty not ready" }) + "\n");
+              }
+            } else if (req.type === PTY_SOCKET_MESSAGE_TYPES.RESIZE && req.cols && req.rows) {
+              if (ptyProcess && ptyAlive && typeof ptyProcess.resize === "function") {
+                ptyProcess.resize(req.cols, req.rows);
+              }
+              if (term && typeof term.resize === "function") {
+                try { term.resize(req.cols, req.rows); } catch { /* ignore */ }
+              }
+              client.write(JSON.stringify({ ok: true }) + "\n");
+            } else if (req.type === PTY_SOCKET_MESSAGE_TYPES.SUBSCRIBE) {
+              outputSubscribers.add(client);
+              client.write(JSON.stringify({ type: PTY_SOCKET_MESSAGE_TYPES.SUBSCRIBED, ok: true }) + "\n");
+              const mode = req.mode === PTY_SOCKET_SUBSCRIBE_MODES.SCREEN
+                ? PTY_SOCKET_SUBSCRIBE_MODES.SCREEN
+                : PTY_SOCKET_SUBSCRIBE_MODES.FULL;
+              if (mode === PTY_SOCKET_SUBSCRIBE_MODES.FULL) {
+                if (outputRingBuffer.length > 0) {
+                  try {
+                    client.write(JSON.stringify({
+                      type: PTY_SOCKET_MESSAGE_TYPES.REPLAY,
+                      data: outputRingBuffer,
+                      encoding: "utf8",
+                    }) + "\n");
+                  } catch {
+                    // ignore replay send errors
+                  }
+                } else {
+                  serializeSnapshot(PTY_SOCKET_SUBSCRIBE_MODES.FULL).then((snapshot) => {
+                    if (snapshot && snapshot.data) {
+                      try {
+                        client.write(JSON.stringify({
+                          type: PTY_SOCKET_MESSAGE_TYPES.SNAPSHOT,
+                          data: snapshot.data,
+                          encoding: "utf8",
+                        }) + "\n");
+                      } catch {
+                        // ignore snapshot send errors
+                      }
+                    }
+                  }).catch(() => {});
+                }
+              } else {
+                serializeSnapshot(PTY_SOCKET_SUBSCRIBE_MODES.SCREEN).then((snapshot) => {
+                  if (snapshot && snapshot.data) {
+                    try {
+                      client.write(JSON.stringify({
+                        type: PTY_SOCKET_MESSAGE_TYPES.SNAPSHOT,
+                        data: snapshot.data,
+                        encoding: "utf8",
+                      }) + "\n");
+                    } catch {
+                      // ignore snapshot send errors
+                    }
+                  }
+                }).catch(() => {});
+              }
+            } else {
+              client.write(JSON.stringify({ ok: false, error: "invalid request" }) + "\n");
+            }
+          } catch (err) {
+            client.write(JSON.stringify({ ok: false, error: err.message }) + "\n");
+          }
+        }
+      });
+      client.on("error", () => {
+        outputSubscribers.delete(client);
+      });
+      client.on("close", () => {
+        outputSubscribers.delete(client);
+      });
+    });
+    server.listen(injectSockPath);
+    return server;
+  }
+
+  function cleanupInjectServer(server) {
+    for (const sub of outputSubscribers) {
+      try { sub.destroy(); } catch { /* ignore */ }
+    }
+    outputSubscribers.clear();
+    try {
+      if (server) server.close();
+      if (fs.existsSync(injectSockPath)) fs.unlinkSync(injectSockPath);
+    } catch {
+      // ignore
+    }
   }
 
   function flushPending() {
@@ -157,7 +451,9 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
 
   function deliverChunk(chunk) {
     if (!chunk) return;
-    const payload = JSON.stringify({ stream: true, delta: chunk });
+    const cleaned = sanitizeChunk(chunk);
+    if (!cleaned) return;
+    const payload = JSON.stringify({ stream: true, delta: cleaned });
     if (currentPublisher) {
       enqueueSend(currentPublisher, payload);
     } else {
@@ -197,9 +493,33 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
 
   function attachPty(proc) {
     proc.onData((data) => {
-      const clean = stripAnsi(String(data || "")).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      const raw = String(data || "");
+      broadcastOutput(raw);
+      // Auto-respond to DSR (Device Status Report) cursor position query.
+      // Ink/codex sends \x1b[6n at startup; node-pty doesn't reply automatically,
+      // causing codex to crash with "cursor position could not be read".
+      if (raw.includes("\x1b[6n") || raw.includes("\x1b[?6n")) {
+        proc.write("\x1b[1;1R");
+      }
+      const clean = stripAnsi(raw).replace(/\r\n/g, "\n").replace(/\r/g, "\n");
       if (!clean) return;
       outputBuffer += clean;
+      if (suppressEcho) {
+        if (echoMarker && outputBuffer.includes(echoMarker)) {
+          const idx = outputBuffer.indexOf(echoMarker);
+          outputBuffer = outputBuffer.slice(idx + echoMarker.length);
+          outputBuffer = outputBuffer.replace(/^\n+/, "");
+          suppressEcho = false;
+          currentMarker = echoMarker;
+          echoMarker = "";
+          if (suppressTimer) {
+            clearTimeout(suppressTimer);
+            suppressTimer = null;
+          }
+        } else {
+          return;
+        }
+      }
       if (currentMarker) {
         const idx = outputBuffer.indexOf(currentMarker);
         if (idx !== -1) {
@@ -208,6 +528,9 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
           if (before) {
             deliverChunk(before);
           }
+          if (currentPublisher) {
+            enqueueSend(currentPublisher, JSON.stringify({ stream: true, done: true, reason: "marker" }));
+          }
           currentMarker = "";
           busy = false;
           currentPublisher = "";
@@ -224,10 +547,29 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
         }
       }
       scheduleFlush();
+      // Ready detection: during TUI startup, reset the quiet timer on each output.
+      // Once output stops for READY_QUIET_MS, the TUI is considered initialized.
+      if (!ptyReady && !busy) {
+        if (readyTimer) clearTimeout(readyTimer);
+        readyTimer = setTimeout(() => {
+          readyTimer = null;
+          if (!ptyReady) {
+            ptyReady = true;
+            // Discard TUI startup noise accumulated before ready
+            outputBuffer = "";
+            pendingOutput = [];
+            logNote("[internal-pty] TUI ready (output quiet for " + READY_QUIET_MS + "ms)");
+            processQueue();
+          }
+        }, READY_QUIET_MS);
+      }
       if (busy) {
         if (idleTimer) clearTimeout(idleTimer);
         idleTimer = setTimeout(() => {
           idleTimer = null;
+          if (currentPublisher) {
+            enqueueSend(currentPublisher, JSON.stringify({ stream: true, done: true, reason: "idle" }));
+          }
           busy = false;
           currentPublisher = "";
           processQueue();
@@ -236,6 +578,15 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     });
 
     proc.onExit(({ exitCode, signal }) => {
+      // Skip if this process has been replaced (e.g., by restartPty)
+      if (proc !== ptyProcess) return;
+
+      ptyAlive = false;
+      ptyReady = false;
+      if (readyTimer) {
+        clearTimeout(readyTimer);
+        readyTimer = null;
+      }
       if (outputBuffer) {
         flushOutput();
       }
@@ -247,14 +598,56 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
         clearTimeout(idleTimer);
         idleTimer = null;
       }
+      if (watchdogTimer) {
+        clearTimeout(watchdogTimer);
+        watchdogTimer = null;
+      }
       const note = `[internal-pty] process exited code=${exitCode} signal=${signal || ""}`.trim();
       if (currentPublisher) enqueueSend(currentPublisher, note);
       logNote(note);
-      running = false;
+
+      // Reset busy state
+      busy = false;
+      currentPublisher = "";
+      currentMarker = "";
+
+      // If stop() was called, let the runner exit
+      if (!running) return;
+
+      // Auto-restart with backoff
+      const elapsed = Date.now() - lastSpawnTime;
+      if (elapsed > RESTART_STABLE_MS) {
+        restartCount = 0; // Process was stable long enough, reset counter
+      }
+      restartCount++;
+
+      if (restartCount <= MAX_RESTARTS) {
+        const delay = Math.min(restartCount * RESTART_DELAY_MS, 10000);
+        logNote(`Auto-restarting PTY in ${delay}ms (attempt ${restartCount}/${MAX_RESTARTS})`);
+        setTimeout(() => {
+          if (!running) return;
+          try {
+            ptyProcess = spawnPtyProcess();
+            processQueue();
+          } catch (err) {
+            logNote(`Restart failed: ${err.message || err}`);
+            void fallbackHeadless(`restart failed: ${err.message || err}`);
+          }
+        }, delay);
+      } else {
+        logNote(`Max PTY restarts (${MAX_RESTARTS}) reached, falling back to headless runner`);
+        void fallbackHeadless("max PTY restarts exceeded");
+      }
     });
   }
 
   function spawnPtyProcess() {
+    lastSpawnTime = Date.now();
+    ptyReady = false;
+    if (readyTimer) {
+      clearTimeout(readyTimer);
+      readyTimer = null;
+    }
     const proc = pty.spawn(command, args, {
       name: "xterm-256color",
       cols: 80,
@@ -262,6 +655,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
       cwd: projectRoot,
       env,
     });
+    ptyAlive = true;
     attachPty(proc);
     return proc;
   }
@@ -269,11 +663,16 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
   function restartPty(reason) {
     if (!running) return;
     logNote(`Restarting PTY: ${reason}`);
+    ptyAlive = false;
+    ptyReady = false;
     if (outputBuffer) {
       flushOutput();
     }
+    // Clear reference first so the old onExit handler skips (proc !== ptyProcess)
+    const oldPty = ptyProcess;
+    ptyProcess = null;
     try {
-      if (ptyProcess) ptyProcess.kill();
+      if (oldPty) oldPty.kill();
     } catch {
       // ignore
     }
@@ -287,6 +686,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     if (outputBuffer) {
       flushOutput();
     }
+    cleanupInjectServer(injectServer);
     try {
       if (ptyProcess) ptyProcess.kill();
     } catch {
@@ -299,6 +699,7 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
 
   const stop = () => {
     running = false;
+    cleanupInjectServer(injectServer);
     try {
       if (ptyProcess) ptyProcess.kill();
     } catch {
@@ -308,22 +709,62 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
 
   process.on("SIGTERM", stop);
   process.on("SIGINT", stop);
+  // Ignore SIGHUP so terminal closure doesn't kill the ptyRunner
+  // while the daemon is still alive.
+  process.on("SIGHUP", () => {});
 
   ptyProcess = spawnPtyProcess();
 
   function processQueue() {
-    if (busy || messageQueue.length === 0 || !running) return;
+    if (busy || messageQueue.length === 0 || !running || !ptyAlive || !ptyReady) return;
     const next = messageQueue.shift();
     if (!next) return;
     busy = true;
     currentPublisher = next.publisher;
     currentMarker = next.marker || "";
+    if (suppressTimer) {
+      clearTimeout(suppressTimer);
+      suppressTimer = null;
+    }
     flushPending();
     if (next.text) {
       if (next.raw) {
         ptyProcess.write(next.text);
       } else {
-        ptyProcess.write(`${buildPrompt(next.text, currentMarker)}\n`);
+        // Write text first, then send Enter separately.
+        // Codex Ink TUI requires text and submit key as separate writes.
+        // IMPORTANT: Defer marker detection until after Enter is sent,
+        // because the prompt echo (TextInput display) contains the marker text.
+        const prompt = buildPrompt(next.text, currentMarker);
+        const savedMarker = currentMarker;
+        suppressEcho = true;
+        echoMarker = savedMarker;
+        currentMarker = ""; // Disable marker detection during prompt echo & formatted display
+        ptyProcess.write(prompt);
+        setTimeout(() => {
+          if (ptyProcess && ptyAlive) {
+            outputBuffer = "";
+            // Send ESC first to dismiss any auto-complete/suggestion overlay
+            // in Ink-based TUIs (Claude Code, Codex), then CR to submit.
+            // This matches the inject socket pattern in launcher.js.
+            ptyProcess.write("\x1b");
+            setTimeout(() => {
+              if (ptyProcess && ptyAlive) {
+                ptyProcess.write("\r");
+              }
+              // Fallback: if we never observe the marker in echoed output,
+              // stop suppressing after a short delay to avoid freezing output.
+              suppressTimer = setTimeout(() => {
+                suppressTimer = null;
+                if (!suppressEcho) return;
+                suppressEcho = false;
+                echoMarker = "";
+                currentMarker = savedMarker;
+                outputBuffer = "";
+              }, 1500);
+            }, 100);
+          }
+        }, 200);
       }
     }
     if (watchdogTimer) clearTimeout(watchdogTimer);
@@ -332,6 +773,9 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
       if (!busy) return;
       const timeoutNote = `[internal-pty] marker timeout; action=${watchdogAction}`;
       if (currentPublisher) enqueueSend(currentPublisher, timeoutNote);
+      if (currentPublisher) {
+        enqueueSend(currentPublisher, JSON.stringify({ stream: true, done: true, reason: "timeout" }));
+      }
       logNote(timeoutNote);
       if (watchdogAction === "fallback") {
         void fallbackHeadless("marker timeout");
@@ -347,7 +791,30 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
     }, watchdogMs);
   }
 
+  // Heartbeat to keep agent "online" in bus status
+  let lastHeartbeat = 0;
+  const HEARTBEAT_INTERVAL = 30000;
+  const updateHeartbeat = () => {
+    try {
+      spawnSync("ufoo", ["bus", "check", subscriber], {
+        cwd: projectRoot,
+        env: { ...process.env, UFOO_SUBSCRIBER_ID: subscriber },
+        stdio: "ignore",
+        timeout: 5000,
+      });
+    } catch {
+      // ignore heartbeat errors
+    }
+  };
+
   while (running) {
+    // Periodic heartbeat
+    const now = Date.now();
+    if (now - lastHeartbeat > HEARTBEAT_INTERVAL) {
+      updateHeartbeat();
+      lastHeartbeat = now;
+    }
+
     const lines = drainQueue(queueFile);
     if (lines.length > 0) {
       const events = [];
@@ -365,7 +832,10 @@ async function runPtyRunner({ projectRoot, agentType = "codex" }) {
           messageQueue.shift();
         }
         const marker = raw ? "" : `__UFOO_DONE_${Date.now()}_${Math.random().toString(16).slice(2)}__`;
-        messageQueue.push({ publisher: evt.publisher || "unknown", raw, text, marker });
+        const publisher = typeof evt.publisher === "object" && evt.publisher
+          ? (evt.publisher.subscriber || evt.publisher.nickname || "unknown")
+          : (evt.publisher || "unknown");
+        messageQueue.push({ publisher, raw, text, marker });
       }
     }
     processQueue();