svamp-cli 0.1.74 → 0.1.76

package/dist/{run-6QgabuQN.mjs → run-BnFGIK0c.mjs}

@@ -1,7 +1,7 @@
 import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import os__default from 'os';
 import fs, { mkdir as mkdir$1, readdir, readFile, writeFile as writeFile$1, rename, unlink } from 'fs/promises';
 import { readFileSync as readFileSync$1, mkdirSync, writeFileSync, renameSync, existsSync as existsSync$1, copyFileSync, unlinkSync, watch, rmdirSync } from 'fs';
-import path, { join, dirname, resolve, basename } from 'path';
+import path__default, { join, dirname, resolve, basename } from 'path';
 import { fileURLToPath } from 'url';
 import { spawn as spawn$1 } from 'child_process';
 import { randomUUID as randomUUID$1 } from 'crypto';
@@ -294,6 +294,33 @@ function applySecurityContext(baseConfig, context) {
   return config;
 }
 
+const terminalSessions = /* @__PURE__ */ new Map();
+let ptyModule = null;
+async function getPtyModule() {
+  if (!ptyModule) {
+    try {
+      ptyModule = await import('node-pty');
+    } catch {
+      throw new Error("node-pty is not available. Install it with: npm install node-pty");
+    }
+  }
+  return ptyModule;
+}
+function generateTerminalId() {
+  return `term-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+const ALLOWED_CONTROL_CHARS = /* @__PURE__ */ new Set([7, 8, 9, 10, 11, 12, 13, 27]);
+function filterForXterm(text) {
+  if (!text) return text;
+  let result = "";
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code >= 32 && code <= 126 || ALLOWED_CONTROL_CHARS.has(code) || code > 127) {
+      result += text[i];
+    }
+  }
+  return result;
+}
 function getMachineMetadataPath(svampHomeDir) {
   return join(svampHomeDir, "machine-metadata.json");
 }
@@ -667,6 +694,125 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           });
         });
       },
+      // ── Terminal PTY RPC ──────────────────────────────────────────────
+      /** Start a new terminal PTY session. Returns { sessionId, cols, rows }. */
+      terminalStart: async (params = {}, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const pty = await getPtyModule();
+        const { homedir: getHomedir } = await import('os');
+        const cols = params.cols || 80;
+        const rows = params.rows || 24;
+        const cwd = params.cwd || getHomedir();
+        const shell = params.shell || process.env.SHELL || "bash";
+        const sessionId = generateTerminalId();
+        const ptyProcess = pty.spawn(shell, [], {
+          name: "xterm-256color",
+          cols,
+          rows,
+          cwd,
+          env: { ...process.env, TERM: "xterm-256color" }
+        });
+        const session = {
+          id: sessionId,
+          pty: ptyProcess,
+          outputBuffer: [],
+          exited: false,
+          cols,
+          rows,
+          createdAt: Date.now(),
+          cwd
+        };
+        terminalSessions.set(sessionId, session);
+        ptyProcess.onData((data) => {
+          const filtered = filterForXterm(data);
+          if (!filtered) return;
+          session.outputBuffer.push(filtered);
+          if (session.outputBuffer.length > 1e3) {
+            session.outputBuffer.splice(0, session.outputBuffer.length - 500);
+          }
+          try {
+            server.emit({
+              type: "svamp:terminal-output",
+              data: { type: "output", content: filtered, sessionId },
+              to: "*"
+            });
+          } catch {
+          }
+        });
+        ptyProcess.onExit(({ exitCode, signal }) => {
+          session.exited = true;
+          session.exitCode = exitCode;
+          session.exitSignal = signal;
+          try {
+            server.emit({
+              type: "svamp:terminal-output",
+              data: { type: "exit", content: "", sessionId, exitCode, signal },
+              to: "*"
+            });
+          } catch {
+          }
+        });
+        return { sessionId, cols, rows };
+      },
+      /** Write data (keystrokes) to a terminal session. */
+      terminalWrite: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const session = terminalSessions.get(params.sessionId);
+        if (!session) throw new Error(`Terminal session ${params.sessionId} not found`);
+        session.pty.write(params.data);
+        return { success: true };
+      },
+      /** Resize a terminal session. */
+      terminalResize: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const session = terminalSessions.get(params.sessionId);
+        if (!session) throw new Error(`Terminal session ${params.sessionId} not found`);
+        session.pty.resize(params.cols, params.rows);
+        session.cols = params.cols;
+        session.rows = params.rows;
+        return { success: true };
+      },
+      /**
+       * Read buffered output from a terminal session (polling).
+       * Returns { output, exited, exitCode? }. Drains the buffer.
+       */
+      terminalRead: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const session = terminalSessions.get(params.sessionId);
+        if (!session) throw new Error(`Terminal session ${params.sessionId} not found`);
+        const output = session.outputBuffer.splice(0).join("");
+        const result = {
+          output,
+          exited: session.exited
+        };
+        if (session.exited) {
+          result.exitCode = session.exitCode;
+          result.exitSignal = session.exitSignal;
+          if (!output) terminalSessions.delete(params.sessionId);
+        }
+        return result;
+      },
+      /** Stop (kill) a terminal session. */
+      terminalStop: async (params, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "admin");
+        const session = terminalSessions.get(params.sessionId);
+        if (!session) throw new Error(`Terminal session ${params.sessionId} not found`);
+        session.pty.kill();
+        terminalSessions.delete(params.sessionId);
+        return { success: true };
+      },
+      /** List active terminal sessions. */
+      terminalList: async (context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        return Array.from(terminalSessions.values()).map((s) => ({
+          sessionId: s.id,
+          cols: s.cols,
+          rows: s.rows,
+          cwd: s.cwd,
+          createdAt: s.createdAt,
+          exited: s.exited
+        }));
+      },
       // Machine-level directory listing (read-only, view role)
       listDirectory: async (path, options, context) => {
         authorizeRequest(context, currentMetadata.sharing, "view");
@@ -874,20 +1020,21 @@ async function registerMachineService(server, machineId, metadata, daemonState,
 function isStructuredMessage(msg) {
   return !!(msg.from && msg.subject);
 }
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
 function formatInboxMessageXml(msg) {
   if (!isStructuredMessage(msg)) return msg.body;
-  const attrs = [
-    `message-id="${msg.messageId}"`,
-    `from="${msg.from}"`,
-    `from-session="${msg.fromSession || ""}"`,
-    `to="${msg.to || ""}"`,
-    `subject="${msg.subject}"`,
-    `urgency="${msg.urgency || "normal"}"`,
-    `timestamp="${msg.timestamp}"`
-  ];
-  if (msg.replyTo) attrs.push(`reply-to="${msg.replyTo}"`);
-  if (msg.cc && msg.cc.length > 0) attrs.push(`cc="${msg.cc.join(",")}"`);
-  if (msg.threadId) attrs.push(`thread-id="${msg.threadId}"`);
+  const attrs = [`message-id="${escapeXml(msg.messageId)}"`];
+  if (msg.from) attrs.push(`from="${escapeXml(msg.from)}"`);
+  if (msg.fromSession) attrs.push(`from-session="${escapeXml(msg.fromSession)}"`);
+  if (msg.to) attrs.push(`to="${escapeXml(msg.to)}"`);
+  if (msg.subject) attrs.push(`subject="${escapeXml(msg.subject)}"`);
+  if (msg.urgency) attrs.push(`urgency="${msg.urgency}"`);
+  if (msg.replyTo) attrs.push(`reply-to="${escapeXml(msg.replyTo)}"`);
+  if (msg.cc && msg.cc.length > 0) attrs.push(`cc="${msg.cc.map(escapeXml).join(",")}"`);
+  if (msg.threadId) attrs.push(`thread-id="${escapeXml(msg.threadId)}"`);
+  attrs.push(`timestamp="${msg.timestamp}"`);
   return `<svamp-message ${attrs.join(" ")}>
 ${msg.body}
 </svamp-message>`;
@@ -933,6 +1080,8 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
     mode: "remote",
     time: Date.now()
   };
+  const inbox = [];
+  const INBOX_MAX = 100;
   const listeners = [];
   const removeListener = (listener, reason) => {
     const idx = listeners.indexOf(listener);
@@ -1268,24 +1417,6 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       });
       return await callbacks.onUpdateSecurityContext(newSecurityContext);
     },
-    /** Toggle isolation (nono/docker/podman) on or off — triggers agent restart */
-    updateIsolation: async (enabled, context) => {
-      authorizeRequest(context, metadata.sharing, "admin");
-      if (metadata.sharing && context?.user?.email && metadata.sharing.owner && context.user.email.toLowerCase() !== metadata.sharing.owner.toLowerCase()) {
-        throw new Error("Only the session owner can change isolation settings");
-      }
-      if (!callbacks.onUpdateIsolation) {
-        throw new Error("Isolation updates are not supported for this session");
-      }
-      metadata = { ...metadata, forceIsolation: enabled };
-      metadataVersion++;
-      notifyListeners({
-        type: "update-session",
-        sessionId,
-        metadata: { value: metadata, version: metadataVersion }
-      });
-      return await callbacks.onUpdateIsolation(enabled);
-    },
     /** Apply a new system prompt and restart the agent process */
     applySystemPrompt: async (prompt, context) => {
       authorizeRequest(context, metadata.sharing, "admin");
@@ -1294,85 +1425,42 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       }
       return await callbacks.onApplySystemPrompt(prompt);
     },
-    // ── Inbox Messaging ──
+    // ── Inbox ──
     sendInboxMessage: async (message, context) => {
       authorizeRequest(context, metadata.sharing, "interact");
-      if (!message.messageId || !message.body) {
-        throw new Error("Inbox message requires messageId and body");
-      }
-      const inbox = (metadata.inbox || []).slice();
-      inbox.push({ ...message, read: false });
-      if (inbox.length > 100) {
-        const readIdx = inbox.findIndex((m) => m.read);
-        if (readIdx >= 0) {
-          inbox.splice(readIdx, 1);
-        } else {
-          inbox.shift();
-        }
-      }
-      metadata = { ...metadata, inbox };
-      metadataVersion++;
-      notifyListeners({
-        type: "update-session",
-        sessionId,
-        metadata: { value: metadata, version: metadataVersion }
-      });
+      inbox.push(message);
+      while (inbox.length > INBOX_MAX) inbox.shift();
       callbacks.onInboxMessage?.(message);
-      return { messageId: message.messageId, delivered: true };
+      notifyListeners({ type: "inbox-update", sessionId, message });
+      return { success: true, messageId: message.messageId };
     },
     getInbox: async (opts, context) => {
       authorizeRequest(context, metadata.sharing, "view");
-      let inbox = metadata.inbox || [];
-      if (opts?.unreadOnly) {
-        inbox = inbox.filter((m) => !m.read);
-      }
-      if (opts?.limit && opts.limit > 0) {
-        inbox = inbox.slice(-opts.limit);
-      }
-      return { messages: inbox, total: (metadata.inbox || []).length };
+      let result = [...inbox];
+      if (opts?.unread) result = result.filter((m) => !m.read);
+      result.sort((a, b) => b.timestamp - a.timestamp);
+      if (opts?.limit && opts.limit > 0) result = result.slice(0, opts.limit);
+      return { messages: result, total: inbox.length };
     },
-    markInboxRead: async (messageIds, context) => {
+    markInboxRead: async (messageId, context) => {
       authorizeRequest(context, metadata.sharing, "interact");
-      let updated = 0;
-      const inbox = (metadata.inbox || []).map((m) => {
-        if (messageIds.includes(m.messageId) && !m.read) {
-          updated++;
-          return { ...m, read: true };
-        }
-        return m;
-      });
-      if (updated > 0) {
-        metadata = { ...metadata, inbox };
-        metadataVersion++;
-        notifyListeners({
-          type: "update-session",
-          sessionId,
-          metadata: { value: metadata, version: metadataVersion }
-        });
-      }
-      return { updated };
+      const msg = inbox.find((m) => m.messageId === messageId);
+      if (!msg) return { success: false, error: "Message not found" };
+      msg.read = true;
+      notifyListeners({ type: "inbox-update", sessionId, message: msg });
+      return { success: true };
     },
-    clearInbox: async (messageIds, context) => {
-      authorizeRequest(context, metadata.sharing, "interact");
-      const currentInbox = metadata.inbox || [];
-      let removed;
-      if (messageIds && messageIds.length > 0) {
-        const newInbox = currentInbox.filter((m) => !messageIds.includes(m.messageId));
-        removed = currentInbox.length - newInbox.length;
-        metadata = { ...metadata, inbox: newInbox.length > 0 ? newInbox : void 0 };
+    clearInbox: async (opts, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (opts?.all) {
+        inbox.length = 0;
       } else {
-        removed = currentInbox.length;
-        metadata = { ...metadata, inbox: void 0 };
-      }
-      if (removed > 0) {
-        metadataVersion++;
-        notifyListeners({
-          type: "update-session",
-          sessionId,
-          metadata: { value: metadata, version: metadataVersion }
-        });
+        for (let i = inbox.length - 1; i >= 0; i--) {
+          if (inbox[i].read) inbox.splice(i, 1);
+        }
       }
-      return { removed };
+      notifyListeners({ type: "inbox-update", sessionId, cleared: true });
+      return { success: true, remaining: inbox.length };
     },
     // ── Listener Registration ──
     registerListener: async (callback, context) => {
@@ -4158,6 +4246,8 @@ function sanitizeEnvForSharing(env) {
 const DEFAULT_PROBE_INTERVAL_S = 10;
 const DEFAULT_PROBE_TIMEOUT_S = 5;
 const DEFAULT_PROBE_FAILURE_THRESHOLD = 3;
+const MAX_RESTART_DELAY_S = 300;
+const BACKOFF_RESET_WINDOW_MS = 6e4;
 const MAX_LOG_LINES = 300;
 class ProcessSupervisor {
   entries = /* @__PURE__ */ new Map();
@@ -4355,7 +4445,7 @@ class ProcessSupervisor {
     for (const file of files) {
       if (!file.endsWith(".json")) continue;
       try {
-        const raw = await readFile(path.join(this.persistDir, file), "utf-8");
+        const raw = await readFile(path__default.join(this.persistDir, file), "utf-8");
         const spec = JSON.parse(raw);
         const entry = this.makeEntry(spec);
         this.entries.set(spec.id, entry);
@@ -4376,14 +4466,14 @@ class ProcessSupervisor {
     }
   }
   async persistSpec(spec) {
-    const filePath = path.join(this.persistDir, `${spec.id}.json`);
+    const filePath = path__default.join(this.persistDir, `${spec.id}.json`);
     const tmpPath = filePath + ".tmp";
     await writeFile$1(tmpPath, JSON.stringify(spec, null, 2), "utf-8");
     await rename(tmpPath, filePath);
   }
   async deleteSpec(id) {
     try {
-      await unlink(path.join(this.persistDir, `${id}.json`));
+      await unlink(path__default.join(this.persistDir, `${id}.json`));
     } catch {
     }
   }
@@ -4489,8 +4579,19 @@ class ProcessSupervisor {
       state.status = "failed";
       return;
     }
-    const delayMs = spec.restartDelay * 1e3;
-    console.log(`[SUPERVISOR] Scheduling restart of '${spec.name}' in ${delayMs}ms (restart #${state.restartCount + 1})`);
+    const uptime = state.startedAt ? Date.now() - state.startedAt : 0;
+    const baseDelay = spec.restartDelay * 1e3;
+    let delayMs;
+    if (uptime > BACKOFF_RESET_WINDOW_MS) {
+      state.restartCount = 0;
+      delayMs = baseDelay;
+    } else {
+      const backoffExponent = Math.min(state.restartCount, 10);
+      delayMs = Math.min(baseDelay * Math.pow(2, backoffExponent), MAX_RESTART_DELAY_S * 1e3);
+      const jitter = (Math.random() * 0.2 - 0.1) * delayMs;
+      delayMs = Math.max(baseDelay, Math.round(delayMs + jitter));
+    }
+    console.log(`[SUPERVISOR] Scheduling restart of '${spec.name}' in ${delayMs}ms (restart #${state.restartCount + 1}, uptime=${Math.round(uptime / 1e3)}s)`);
     entry.restartTimer = setTimeout(() => {
       if (entry.stopping) return;
       state.restartCount++;
@@ -4971,16 +5072,15 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
         const progressRelPath = `.svamp/${sessionId}/ralph-progress.md`;
         const prompt = buildRalphPrompt(state.task, state);
         const ralphSysPrompt = buildRalphSystemPrompt(state, progressRelPath);
-        const existingInbox = getMetadata().inbox || [];
+        const existingQueue = getMetadata().messageQueue || [];
         setMetadata((m) => ({
           ...m,
           ralphLoop,
-          inbox: [...existingInbox, {
-            messageId: randomUUID$1(),
-            body: prompt,
+          messageQueue: [...existingQueue, {
+            id: randomUUID$1(),
+            text: prompt,
             displayText: state.task,
-            timestamp: Date.now(),
-            read: false,
+            createdAt: Date.now(),
             ralphSystemPrompt: ralphSysPrompt
           }]
         }));
@@ -5648,8 +5748,7 @@ async function startDaemon(options) {
             }
           });
         }, buildIsolationConfig2 = function(dir) {
-          const forceIsolation = sessionMetadata.forceIsolation ?? options2.forceIsolation;
-          if (!forceIsolation && !sessionMetadata.sharing?.enabled) return null;
+          if (!options2.forceIsolation && !sessionMetadata.sharing?.enabled) return null;
           const method = isolationCapabilities.preferred;
           if (!method) return null;
           const detail = isolationCapabilities.details[method];
@@ -5690,7 +5789,6 @@ async function startDaemon(options) {
           lifecycleState: resumeSessionId ? "idle" : "starting",
           sharing: options2.sharing,
           securityContext: options2.securityContext,
-          forceIsolation: options2.forceIsolation || void 0,
           tags: options2.tags,
           parentSessionId: options2.parentSessionId,
           ...options2.parentSessionId && (() => {
@@ -5766,8 +5864,7 @@ async function startDaemon(options) {
           startupNonJsonLines = [];
           startupRetryMessage = initialMessage;
           let rawPermissionMode = effectiveMeta.permissionMode || agentConfig.default_permission_mode || currentPermissionMode;
-          const forceIsolation = sessionMetadata.forceIsolation ?? options2.forceIsolation;
-          if (forceIsolation || sessionMetadata.sharing?.enabled) {
+          if (options2.forceIsolation || sessionMetadata.sharing?.enabled) {
             rawPermissionMode = rawPermissionMode === "default" ? "auto-approve-all" : rawPermissionMode;
           }
           if (sessionMetadata.ralphLoop?.active) {
@@ -5804,7 +5901,7 @@ async function startDaemon(options) {
             if (wrapped.cleanupFiles) isolationCleanupFiles = wrapped.cleanupFiles;
             sessionMetadata = { ...sessionMetadata, isolationMethod: isoConfig.method };
             logger.log(`[Session ${sessionId}] Isolation: ${isoConfig.method} (binary: ${isoConfig.binaryPath})`);
-          } else if (forceIsolation || sessionMetadata.sharing?.enabled) {
+          } else if (options2.forceIsolation || sessionMetadata.sharing?.enabled) {
             logger.log(`[Session ${sessionId}] WARNING: No isolation runtime (nono/docker/podman) available. Session is NOT sandboxed.`);
             sessionMetadata = { ...sessionMetadata, isolationMethod: void 0 };
           } else {
@@ -6029,7 +6126,7 @@ async function startDaemon(options) {
                       logger.log(`[Session ${sessionId}] ${taskInfo}`);
                       sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
                     }
-                    const queueLen = sessionMetadata.inbox?.filter((m) => !m.read)?.length ?? 0;
+                    const queueLen = sessionMetadata.messageQueue?.length ?? 0;
                     if (msg.is_error) {
                       const rlStateForError = readRalphState(getRalphStateFilePath(directory, sessionId));
                       if (rlStateForError) {
@@ -6330,11 +6427,12 @@ The automated loop has finished. Review the progress above and let me know if yo
                 logger.log(`[Session ${sessionId}] Retrying startup without --resume`);
                 sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
                 sessionService.updateMetadata(sessionMetadata);
+                sessionService.sendKeepAlive(true);
                 spawnClaude(startupRetryMessage);
                 return;
               }
             }
-            const queueLen = sessionMetadata.inbox?.filter((m) => !m.read)?.length ?? 0;
+            const queueLen = sessionMetadata.messageQueue?.length ?? 0;
             if (queueLen > 0 && claudeResumeId && !trackedSession.stopped) {
               signalProcessing(false);
               setTimeout(() => processMessageQueueRef?.(), 200);
@@ -6445,10 +6543,10 @@ The automated loop has finished. Review the progress above and let me know if yo
               }
               if (isKillingClaude || isRestartingClaude || isSwitchingMode) {
                 logger.log(`[Session ${sessionId}] Message received while restarting Claude, queuing to prevent loss`);
-                const existingInbox = sessionMetadata.inbox || [];
+                const existingQueue = sessionMetadata.messageQueue || [];
                 sessionMetadata = {
                   ...sessionMetadata,
-                  inbox: [...existingInbox, { messageId: randomUUID$1(), body: text, timestamp: Date.now(), read: false }]
+                  messageQueue: [...existingQueue, { id: randomUUID$1(), text, createdAt: Date.now() }]
                 };
                 sessionService.updateMetadata(sessionMetadata);
                 signalProcessing(false);
@@ -6483,7 +6581,7 @@ The automated loop has finished. Review the progress above and let me know if yo
               }
               signalProcessing(false);
               sessionWasProcessing = false;
-              const queueLen = sessionMetadata.inbox?.filter((m) => !m.read)?.length ?? 0;
+              const queueLen = sessionMetadata.messageQueue?.length ?? 0;
               const abortMsg = queueLen > 0 ? `Aborted by user. ${queueLen} queued message(s) will be processed next.` : "Aborted by user";
               sessionService.pushMessage(
                 { type: "message", message: abortMsg },
@@ -6565,24 +6663,6 @@ The automated loop has finished. Review the progress above and let me know if yo
               sessionMetadata = { ...sessionMetadata, securityContext: newSecurityContext };
               return await restartClaudeHandler();
             },
-            onUpdateIsolation: async (enabled) => {
-              logger.log(`[Session ${sessionId}] Isolation ${enabled ? "enabled" : "disabled"} \u2014 restarting agent`);
-              sessionMetadata = { ...sessionMetadata, forceIsolation: enabled };
-              if (!trackedSession.stopped) {
-                saveSession({
-                  sessionId,
-                  directory,
-                  claudeResumeId,
-                  permissionMode: currentPermissionMode,
-                  spawnMeta: lastSpawnMeta,
-                  metadata: sessionMetadata,
-                  createdAt: Date.now(),
-                  machineId,
-                  wasProcessing: sessionWasProcessing
-                });
-              }
-              return await restartClaudeHandler();
-            },
             onSharingUpdate: (newSharing) => {
               logger.log(`[Session ${sessionId}] Sharing config updated \u2014 persisting to disk`);
               sessionMetadata = { ...sessionMetadata, sharing: newSharing };
@@ -6605,72 +6685,33 @@ The automated loop has finished. Review the progress above and let me know if yo
               lastSpawnMeta = { ...lastSpawnMeta, appendSystemPrompt: prompt };
               return await restartClaudeHandler();
             },
+            onKillSession: () => {
+              logger.log(`[Session ${sessionId}] Kill session requested`);
+              stopSession(sessionId);
+            },
             onInboxMessage: (message) => {
-              const xmlText = formatInboxMessageXml(message);
+              if (trackedSession?.stopped) return;
+              logger.log(`[Session ${sessionId}] Inbox message received (urgency: ${message.urgency || "normal"}, from: ${message.from || "unknown"})`);
               if (message.urgency === "urgent") {
-                logger.log(`[Session ${sessionId}] Urgent inbox message from ${message.from}: ${message.subject}`);
-                const text = xmlText;
-                if (sessionWasProcessing) {
-                  const existingInbox = sessionMetadata.inbox || [];
-                  sessionMetadata = { ...sessionMetadata, inbox: [{ messageId: message.messageId, body: text, displayText: `[Inbox] ${message.subject}`, timestamp: Date.now(), read: false, from: message.from, fromSession: message.fromSession, subject: message.subject, urgency: "urgent" }, ...existingInbox] };
-                  sessionService.updateMetadata(sessionMetadata);
+                const formatted = formatInboxMessageXml(message);
+                logger.log(`[Session ${sessionId}] Delivering urgent inbox message to agent`);
+                if (!claudeProcess || claudeProcess.exitCode !== null) {
+                  spawnClaude(formatted);
                 } else {
-                  sessionWasProcessing = true;
-                  signalProcessing(true);
-                  sessionService.pushMessage(`[Inbox] ${message.subject}`, "user");
-                  userMessagePending = true;
-                  turnInitiatedByUser = true;
-                  try {
-                    if (!claudeProcess || claudeProcess.exitCode !== null) {
-                      spawnClaude(text);
-                    } else {
-                      const stdinMsg = JSON.stringify({
-                        type: "user",
-                        message: { role: "user", content: text }
-                      });
-                      claudeProcess.stdin?.write(stdinMsg + "\n");
-                    }
-                  } catch (err) {
-                    logger.log(`[Session ${sessionId}] Error injecting urgent inbox message: ${err.message}`);
-                    sessionWasProcessing = false;
-                    signalProcessing(false);
-                  }
-                }
-                const inbox = (sessionMetadata.inbox || []).map(
-                  (m) => m.messageId === message.messageId ? { ...m, read: true } : m
-                );
-                sessionMetadata = { ...sessionMetadata, inbox };
-                sessionService.updateMetadata(sessionMetadata);
-              } else {
-                logger.log(`[Session ${sessionId}] Normal inbox message from ${message.from}: ${message.subject}`);
-                if (!sessionWasProcessing && !trackedSession.stopped) {
-                  setTimeout(() => processMessageQueueRef?.(), 200);
+                  const stdinMsg = JSON.stringify({
+                    type: "user",
+                    message: { role: "user", content: formatted }
+                  });
+                  claudeProcess.stdin?.write(stdinMsg + "\n");
                 }
+                signalProcessing(true);
+                sessionWasProcessing = true;
               }
             },
-            onKillSession: () => {
-              logger.log(`[Session ${sessionId}] Kill session requested`);
-              stopSession(sessionId);
-            },
             onMetadataUpdate: (newMeta) => {
               const prevRalphLoop = sessionMetadata.ralphLoop;
-              const legacyQueue = newMeta.messageQueue;
-              let migratedInbox = newMeta.inbox || [];
-              if (legacyQueue && legacyQueue.length > 0) {
-                const converted = legacyQueue.map((q) => ({
-                  messageId: q.id,
-                  body: q.text,
-                  displayText: q.displayText,
-                  timestamp: q.createdAt,
-                  read: false
-                }));
-                migratedInbox = [...migratedInbox || [], ...converted];
-              }
               sessionMetadata = {
                 ...newMeta,
-                inbox: migratedInbox.length > 0 ? migratedInbox : newMeta.inbox,
-                // Clear legacy messageQueue — daemon uses inbox only
-                ...legacyQueue && legacyQueue.length > 0 ? { messageQueue: void 0 } : {},
                 // Daemon drives lifecycleState — don't let frontend overwrite with stale value
                 lifecycleState: sessionMetadata.lifecycleState,
                 // Preserve claudeSessionId set by 'system init' (frontend may not have it)
@@ -6686,11 +6727,8 @@ The automated loop has finished. Review the progress above and let me know if yo
               if (prevRalphLoop && !newMeta.ralphLoop) {
                 sessionService.updateMetadata(sessionMetadata);
               }
-              if (legacyQueue && legacyQueue.length > 0) {
-                sessionService.updateMetadata(sessionMetadata);
-              }
-              const unreadInbox = sessionMetadata.inbox?.filter((m) => !m.read);
-              if (unreadInbox && unreadInbox.length > 0 && !sessionWasProcessing && !trackedSession.stopped) {
+              const queue = newMeta.messageQueue;
+              if (queue && queue.length > 0 && !sessionWasProcessing && !trackedSession.stopped) {
                 setTimeout(() => {
                   processMessageQueueRef?.();
                 }, 200);
@@ -6813,18 +6851,16 @@ The automated loop has finished. Review the progress above and let me know if yo
           if (trackedSession?.stopped) return;
           if (isKillingClaude) return;
           if (isRestartingClaude || isSwitchingMode) return;
-          const inbox = sessionMetadata.inbox;
-          const unreadIdx = inbox?.findIndex((m) => !m.read) ?? -1;
-          if (inbox && unreadIdx >= 0) {
-            const next = inbox[unreadIdx];
-            const updatedInbox = inbox.map((m, i) => i === unreadIdx ? { ...m, read: true } : m);
-            sessionMetadata = { ...sessionMetadata, inbox: updatedInbox };
+          const queue = sessionMetadata.messageQueue;
+          if (queue && queue.length > 0) {
+            const next = queue[0];
+            const remaining = queue.slice(1);
+            sessionMetadata = { ...sessionMetadata, messageQueue: remaining.length > 0 ? remaining : void 0 };
             sessionService.updateMetadata(sessionMetadata);
-            const deliverText = isStructuredMessage(next) ? formatInboxMessageXml(next) : next.body;
-            logger.log(`[Session ${sessionId}] Processing inbox message: "${next.body.slice(0, 50)}..."`);
+            logger.log(`[Session ${sessionId}] Processing queued message: "${next.text.slice(0, 50)}..."`);
             sessionWasProcessing = true;
             signalProcessing(true);
-            sessionService.pushMessage(next.displayText || next.body, "user");
+            sessionService.pushMessage(next.displayText || next.text, "user");
             userMessagePending = true;
             turnInitiatedByUser = true;
             const queueMeta = next.ralphSystemPrompt ? { appendSystemPrompt: next.ralphSystemPrompt } : void 0;
@@ -6846,7 +6882,7 @@ The automated loop has finished. Review the progress above and let me know if yo
                   if (trackedSession?.stopped) return;
                   if (isRestartingClaude || isSwitchingMode) return;
                   claudeResumeId = void 0;
-                  spawnClaude(deliverText, queueMeta);
+                  spawnClaude(next.text, queueMeta);
                 } catch (err) {
                   logger.log(`[Session ${sessionId}] Error in fresh Ralph queue processing: ${err.message}`);
                   isKillingClaude = false;
@@ -6857,11 +6893,11 @@ The automated loop has finished. Review the progress above and let me know if yo
             } else {
               try {
                 if (!claudeProcess || claudeProcess.exitCode !== null) {
-                  spawnClaude(deliverText, queueMeta);
+                  spawnClaude(next.text, queueMeta);
                 } else {
                   const stdinMsg = JSON.stringify({
                     type: "user",
-                    message: { role: "user", content: deliverText }
+                    message: { role: "user", content: next.text }
                   });
                   claudeProcess.stdin?.write(stdinMsg + "\n");
                 }
@@ -6994,26 +7030,27 @@ The automated loop has finished. Review the progress above and let me know if yo
               }
               if (!acpBackendReady) {
                 logger.log(`[${agentName} Session ${sessionId}] Backend not ready \u2014 queuing message`);
-                const existingInbox = sessionMetadata.inbox || [];
+                const existingQueue = sessionMetadata.messageQueue || [];
                 sessionMetadata = {
                   ...sessionMetadata,
-                  inbox: [...existingInbox, { messageId: randomUUID$1(), body: text, timestamp: Date.now(), read: false }]
+                  messageQueue: [...existingQueue, { id: randomUUID$1(), text, createdAt: Date.now() }]
                 };
                 sessionService.updateMetadata(sessionMetadata);
                 return;
               }
               if (sessionMetadata.lifecycleState === "running") {
                 logger.log(`[${agentName} Session ${sessionId}] Agent busy \u2014 queuing message`);
-                const existingInbox = sessionMetadata.inbox || [];
+                const existingQueue = sessionMetadata.messageQueue || [];
                 sessionMetadata = {
                   ...sessionMetadata,
-                  inbox: [...existingInbox, { messageId: randomUUID$1(), body: text, timestamp: Date.now(), read: false }]
+                  messageQueue: [...existingQueue, { id: randomUUID$1(), text, createdAt: Date.now() }]
                 };
                 sessionService.updateMetadata(sessionMetadata);
                 return;
               }
               sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
               sessionService.updateMetadata(sessionMetadata);
+              sessionService.sendKeepAlive(true);
               agentBackend.sendPrompt(sessionId, text).catch((err) => {
                 logger.error(`[${agentName} Session ${sessionId}] Error sending prompt:`, err);
                 if (!acpStopped) {
@@ -7064,10 +7101,6 @@ The automated loop has finished. Review the progress above and let me know if yo
               sessionMetadata = { ...sessionMetadata, securityContext: newSecurityContext };
               return { success: false, message: "Security context updates with restart are not yet supported for this agent type." };
             },
-            onUpdateIsolation: async (enabled) => {
-              sessionMetadata = { ...sessionMetadata, forceIsolation: enabled };
-              return { success: false, message: "Isolation changes with restart are not yet supported for this agent type." };
-            },
             onSharingUpdate: (newSharing) => {
               logger.log(`[${agentName} Session ${sessionId}] Sharing config updated \u2014 persisting in-memory`);
               sessionMetadata = { ...sessionMetadata, sharing: newSharing };
@@ -7075,59 +7108,33 @@ The automated loop has finished. Review the progress above and let me know if yo
             onApplySystemPrompt: async () => {
               return { success: false, message: "System prompt updates with restart are not yet supported for this agent type." };
             },
-            onInboxMessage: (message) => {
-              const xmlText = formatInboxMessageXml(message);
-              if (message.urgency === "urgent") {
-                logger.log(`[${agentName} Session ${sessionId}] Urgent inbox message from ${message.from}: ${message.subject}`);
-                if (sessionMetadata.lifecycleState === "running" || !acpBackendReady) {
-                  const existingInbox = sessionMetadata.inbox || [];
-                  sessionMetadata = { ...sessionMetadata, inbox: [{ messageId: message.messageId, body: xmlText, displayText: `[Inbox] ${message.subject}`, timestamp: Date.now(), read: false, from: message.from, fromSession: message.fromSession, subject: message.subject, urgency: "urgent" }, ...existingInbox] };
-                  sessionService.updateMetadata(sessionMetadata);
-                } else {
-                  sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
-                  sessionService.updateMetadata(sessionMetadata);
-                  sessionService.pushMessage(`[Inbox] ${message.subject}`, "user");
-                  agentBackend.sendPrompt(sessionId, xmlText).catch((err) => {
-                    logger.error(`[${agentName} Session ${sessionId}] Error sending urgent inbox: ${err.message}`);
-                    if (!acpStopped) {
-                      sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
-                      sessionService.updateMetadata(sessionMetadata);
-                      sessionService.sendSessionEnd();
-                    }
-                  });
-                }
-                const inbox = (sessionMetadata.inbox || []).map(
-                  (m) => m.messageId === message.messageId ? { ...m, read: true } : m
-                );
-                sessionMetadata = { ...sessionMetadata, inbox };
-                sessionService.updateMetadata(sessionMetadata);
-              } else {
-                logger.log(`[${agentName} Session ${sessionId}] Normal inbox message from ${message.from}: ${message.subject}`);
-              }
-            },
             onKillSession: () => {
               logger.log(`[${agentName} Session ${sessionId}] Kill session requested`);
               stopSession(sessionId);
             },
+            onInboxMessage: (message) => {
+              if (acpStopped) return;
+              logger.log(`[${agentName} Session ${sessionId}] Inbox message received (urgency: ${message.urgency || "normal"}, from: ${message.from || "unknown"})`);
+              if (message.urgency === "urgent" && acpBackendReady) {
+                const formatted = formatInboxMessageXml(message);
+                logger.log(`[${agentName} Session ${sessionId}] Delivering urgent inbox message to agent`);
+                sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
+                sessionService.updateMetadata(sessionMetadata);
+                sessionService.sendKeepAlive(true);
+                agentBackend.sendPrompt(sessionId, formatted).catch((err) => {
+                  logger.error(`[${agentName} Session ${sessionId}] Error delivering urgent inbox message: ${err.message}`);
+                  if (!acpStopped) {
+                    sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
+                    sessionService.updateMetadata(sessionMetadata);
+                    sessionService.sendSessionEnd();
+                  }
+                });
+              }
+            },
             onMetadataUpdate: (newMeta) => {
               const prevRalphLoop = sessionMetadata.ralphLoop;
-              const legacyQueue = newMeta.messageQueue;
-              let migratedInbox = newMeta.inbox || [];
-              if (legacyQueue && legacyQueue.length > 0) {
-                const converted = legacyQueue.map((q) => ({
-                  messageId: q.id,
-                  body: q.text,
-                  displayText: q.displayText,
-                  timestamp: q.createdAt,
-                  read: false
-                }));
-                migratedInbox = [...migratedInbox || [], ...converted];
-              }
               sessionMetadata = {
                 ...newMeta,
-                inbox: migratedInbox.length > 0 ? migratedInbox : newMeta.inbox,
-                // Clear legacy messageQueue — daemon uses inbox only
-                ...legacyQueue && legacyQueue.length > 0 ? { messageQueue: void 0 } : {},
                 // Daemon drives lifecycleState — don't let frontend overwrite with stale value
                 lifecycleState: sessionMetadata.lifecycleState,
                 ...sessionMetadata.summary && !newMeta.summary ? { summary: sessionMetadata.summary } : {},
@@ -7141,24 +7148,17 @@ The automated loop has finished. Review the progress above and let me know if yo
               if (prevRalphLoop && !newMeta.ralphLoop) {
                 sessionService.updateMetadata(sessionMetadata);
               }
-              if (legacyQueue && legacyQueue.length > 0) {
-                sessionService.updateMetadata(sessionMetadata);
-              }
               if (acpStopped) return;
-              const unreadInbox = sessionMetadata.inbox?.filter((m) => !m.read);
-              if (unreadInbox && unreadInbox.length > 0 && sessionMetadata.lifecycleState === "idle") {
-                const next = unreadInbox[0];
-                sessionMetadata = {
-                  ...sessionMetadata,
-                  inbox: (sessionMetadata.inbox || []).map((m) => m.messageId === next.messageId ? { ...m, read: true } : m),
-                  lifecycleState: "running"
-                };
+              const queue = newMeta.messageQueue;
+              if (queue && queue.length > 0 && sessionMetadata.lifecycleState === "idle") {
+                const next = queue[0];
+                const remaining = queue.slice(1);
+                sessionMetadata = { ...sessionMetadata, messageQueue: remaining.length > 0 ? remaining : void 0, lifecycleState: "running" };
                 sessionService.updateMetadata(sessionMetadata);
-                const deliverText = isStructuredMessage(next) ? formatInboxMessageXml(next) : next.body;
-                logger.log(`[Session ${sessionId}] Processing inbox message from metadata update: "${next.body.slice(0, 50)}..."`);
+                logger.log(`[Session ${sessionId}] Processing queued message from metadata update: "${next.text.slice(0, 50)}..."`);
                 sessionService.sendKeepAlive(true);
-                agentBackend.sendPrompt(sessionId, deliverText).catch((err) => {
-                  logger.error(`[Session ${sessionId}] Error processing inbox message: ${err.message}`);
+                agentBackend.sendPrompt(sessionId, next.text).catch((err) => {
+                  logger.error(`[Session ${sessionId}] Error processing queued message: ${err.message}`);
                   if (!acpStopped) {
                     sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
                     sessionService.updateMetadata(sessionMetadata);
@@ -7275,20 +7275,16 @@ The automated loop has finished. Review the progress above and let me know if yo
           () => {
             if (acpStopped) return;
             if (insideOnTurnEnd) return;
-            const unreadInbox = sessionMetadata.inbox?.filter((m) => !m.read);
-            if (unreadInbox && unreadInbox.length > 0 && sessionMetadata.lifecycleState === "idle") {
-              const next = unreadInbox[0];
-              sessionMetadata = {
-                ...sessionMetadata,
-                inbox: (sessionMetadata.inbox || []).map((m) => m.messageId === next.messageId ? { ...m, read: true } : m),
-                lifecycleState: "running"
-              };
+            const queue = sessionMetadata.messageQueue;
+            if (queue && queue.length > 0 && sessionMetadata.lifecycleState === "idle") {
+              const next = queue[0];
+              const remaining = queue.slice(1);
+              sessionMetadata = { ...sessionMetadata, messageQueue: remaining.length > 0 ? remaining : void 0, lifecycleState: "running" };
               sessionService.updateMetadata(sessionMetadata);
-              const deliverText = isStructuredMessage(next) ? formatInboxMessageXml(next) : next.body;
-              logger.log(`[Session ${sessionId}] Processing inbox message (ACP ralph activation): "${next.body.slice(0, 50)}..."`);
+              logger.log(`[Session ${sessionId}] Processing queued message (ACP ralph activation): "${next.text.slice(0, 50)}..."`);
               sessionService.sendKeepAlive(true);
-              agentBackend.sendPrompt(sessionId, deliverText).catch((err) => {
-                logger.error(`[Session ${sessionId}] Error processing inbox message: ${err.message}`);
+              agentBackend.sendPrompt(sessionId, next.text).catch((err) => {
+                logger.error(`[Session ${sessionId}] Error processing queued message: ${err.message}`);
                 if (!acpStopped) {
                   sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
                   sessionService.updateMetadata(sessionMetadata);
@@ -7302,7 +7298,7 @@ The automated loop has finished. Review the progress above and let me know if yo
         const writeSvampConfigPatchAcp = svampConfigChecker.writeConfig;
         const permissionHandler = new HyphaPermissionHandler(shouldAutoAllow2, logger.log);
         let agentIsoConfig;
-        if (((sessionMetadata.forceIsolation ?? options2.forceIsolation) || sessionMetadata.sharing?.enabled) && isolationCapabilities.preferred) {
+        if ((options2.forceIsolation || sessionMetadata.sharing?.enabled) && isolationCapabilities.preferred) {
           const method = isolationCapabilities.preferred;
           const detail = isolationCapabilities.details[method];
           if (detail.found && detail.verified !== false) {
@@ -7370,21 +7366,17 @@ The automated loop has finished. Review the progress above and let me know if yo
                 logger.log(`[${agentName} Session ${sessionId}] ${reason}`);
                 sessionService.pushMessage({ type: "message", message: reason }, "event");
               } else {
-                const pendingInbox = sessionMetadata.inbox?.filter((m) => !m.read);
-                if (pendingInbox && pendingInbox.length > 0) {
-                  const next = pendingInbox[0];
-                  sessionMetadata = {
-                    ...sessionMetadata,
-                    inbox: (sessionMetadata.inbox || []).map((m) => m.messageId === next.messageId ? { ...m, read: true } : m),
-                    lifecycleState: "running"
-                  };
+                const pendingQueue = sessionMetadata.messageQueue;
+                if (pendingQueue && pendingQueue.length > 0) {
+                  const next = pendingQueue[0];
+                  const remaining = pendingQueue.slice(1);
+                  sessionMetadata = { ...sessionMetadata, messageQueue: remaining.length > 0 ? remaining : void 0, lifecycleState: "running" };
                   sessionService.updateMetadata(sessionMetadata);
                   sessionService.sendKeepAlive(true);
-                  const deliverText = isStructuredMessage(next) ? formatInboxMessageXml(next) : next.body;
-                  sessionService.pushMessage(next.displayText || next.body, "user");
-                  logger.log(`[${agentName} Session ${sessionId}] Processing inbox message (priority over Ralph advance): "${next.body.slice(0, 50)}..."`);
-                  agentBackend.sendPrompt(sessionId, deliverText).catch((err) => {
-                    logger.error(`[${agentName} Session ${sessionId}] Error processing inbox message (Ralph): ${err.message}`);
+                  sessionService.pushMessage(next.displayText || next.text, "user");
+                  logger.log(`[${agentName} Session ${sessionId}] Processing queued message (priority over Ralph advance): "${next.text.slice(0, 50)}..."`);
+                  agentBackend.sendPrompt(sessionId, next.text).catch((err) => {
+                    logger.error(`[${agentName} Session ${sessionId}] Error processing queued message (Ralph): ${err.message}`);
                     if (!acpStopped) {
                       sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
                       sessionService.updateMetadata(sessionMetadata);
@@ -7451,21 +7443,17 @@ The automated loop has finished. Review the progress above and let me know if yo
                 return;
               }
             }
-            const unreadInboxItems = sessionMetadata.inbox?.filter((m) => !m.read);
-            if (unreadInboxItems && unreadInboxItems.length > 0) {
-              const next = unreadInboxItems[0];
-              sessionMetadata = {
-                ...sessionMetadata,
-                inbox: (sessionMetadata.inbox || []).map((m) => m.messageId === next.messageId ? { ...m, read: true } : m),
-                lifecycleState: "running"
-              };
+            const queue = sessionMetadata.messageQueue;
+            if (queue && queue.length > 0) {
+              const next = queue[0];
+              const remaining = queue.slice(1);
+              sessionMetadata = { ...sessionMetadata, messageQueue: remaining.length > 0 ? remaining : void 0, lifecycleState: "running" };
               sessionService.updateMetadata(sessionMetadata);
               sessionService.sendKeepAlive(true);
-              const deliverText = isStructuredMessage(next) ? formatInboxMessageXml(next) : next.body;
-              logger.log(`[Session ${sessionId}] Processing inbox message: "${next.body.slice(0, 50)}..."`);
-              sessionService.pushMessage(next.displayText || next.body, "user");
-              agentBackend.sendPrompt(sessionId, deliverText).catch((err) => {
-                logger.error(`[Session ${sessionId}] Error processing inbox message: ${err.message}`);
+              logger.log(`[Session ${sessionId}] Processing queued message: "${next.text.slice(0, 50)}..."`);
+              sessionService.pushMessage(next.displayText || next.text, "user");
+              agentBackend.sendPrompt(sessionId, next.text).catch((err) => {
+                logger.error(`[Session ${sessionId}] Error processing queued message: ${err.message}`);
                 if (!acpStopped) {
                   sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
                   sessionService.updateMetadata(sessionMetadata);
@@ -7676,7 +7664,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             // Restore sharing & security context from persisted metadata
             sharing: persisted.metadata?.sharing,
             securityContext: persisted.metadata?.securityContext,
-            forceIsolation: persisted.metadata?.forceIsolation ?? !!persisted.metadata?.isolationMethod,
+            forceIsolation: !!persisted.metadata?.isolationMethod,
             // Block queue processing until auto-continue completes
             wasProcessing: persisted.wasProcessing && !!persisted.claudeResumeId && !isOrphaned
           });
@@ -7835,7 +7823,6 @@ The automated loop has finished. Review the progress above and let me know if yo
     console.log(`  Log file: ${logger.logFilePath}`);
     const HEARTBEAT_INTERVAL_MS = 1e4;
     const PING_TIMEOUT_MS = 6e4;
-    const MAX_FAILURES = 60;
     const POST_RECONNECT_GRACE_MS = 2e4;
     let heartbeatRunning = false;
     let lastReconnectAt = 0;
@@ -7906,7 +7893,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             if (consecutiveHeartbeatFailures === 1) {
               logger.log(`Ping failed: ${err.message}`);
             } else if (consecutiveHeartbeatFailures % 6 === 0) {
-              logger.log(`Connection down for ${consecutiveHeartbeatFailures * HEARTBEAT_INTERVAL_MS / 1e3}s (${consecutiveHeartbeatFailures}/${MAX_FAILURES})`);
+              logger.log(`Connection down for ${consecutiveHeartbeatFailures * HEARTBEAT_INTERVAL_MS / 1e3}s (${consecutiveHeartbeatFailures} failures, retrying indefinitely)`);
             }
             if (consecutiveHeartbeatFailures === 1 || consecutiveHeartbeatFailures % 3 === 0) {
               const conn = server.rpc?._connection;
@@ -7919,17 +7906,19 @@ The automated loop has finished. Review the progress above and let me know if yo
                 }
               }
               if (conn?._reader) {
-                logger.log("Aborting stale HTTP stream to trigger reconnection");
+                logger.log("Cancelling stale HTTP stream reader to trigger reconnection");
                 try {
                   conn._reader.cancel?.("Stale connection");
                 } catch {
                 }
+              } else if (conn?._abort_controller) {
+                logger.log("Aborting stale HTTP stream to trigger reconnection");
+                try {
+                  conn._abort_controller.abort();
+                } catch {
+                }
               }
             }
-            if (consecutiveHeartbeatFailures >= MAX_FAILURES) {
-              logger.log(`Heartbeat failed ${MAX_FAILURES} times. Shutting down.`);
-              requestShutdown("heartbeat-timeout", err.message);
-            }
           }
         }
       } finally {
@@ -8024,8 +8013,11 @@ The automated loop has finished. Review the progress above and let me know if yo
     };
     const shutdownReq = await resolvesWhenShutdownRequested;
     await cleanup(shutdownReq.source);
-    if (process.env.SVAMP_SUPERVISED === "1" && shutdownReq.source === "version-update") {
-      process.exit(1);
+    if (process.env.SVAMP_SUPERVISED === "1") {
+      const intentionalSources = ["os-signal", "os-signal-cleanup", "hypha-app"];
+      if (!intentionalSources.includes(shutdownReq.source)) {
+        process.exit(1);
+      }
     }
     process.exit(0);
   } catch (error) {