svamp-cli 0.1.74 → 0.1.75

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

@@ -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,107 @@ 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,
+          listeners: [],
+          cols,
+          rows,
+          createdAt: Date.now(),
+          cwd
+        };
+        terminalSessions.set(sessionId, session);
+        ptyProcess.onData((data) => {
+          const filtered = filterForXterm(data);
+          if (!filtered) return;
+          const update = { type: "output", content: filtered, sessionId };
+          for (const listener of session.listeners) {
+            try {
+              listener(update);
+            } catch {
+            }
+          }
+        });
+        ptyProcess.onExit(({ exitCode, signal }) => {
+          const update = { type: "exit", content: "", sessionId, exitCode, signal };
+          for (const listener of session.listeners) {
+            try {
+              listener(update);
+            } catch {
+            }
+          }
+          terminalSessions.delete(sessionId);
+        });
+        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 };
+      },
+      /**
+       * Attach to a terminal session for real-time output streaming.
+       * The onData callback receives { type: 'output'|'exit', content, sessionId }.
+       */
+      terminalAttach: 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`);
+        if (typeof params.onData !== "function") throw new Error("onData callback is required");
+        session.listeners.push(params.onData);
+        return { success: true, cols: session.cols, rows: session.rows };
+      },
+      /** 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
+        }));
+      },
       // Machine-level directory listing (read-only, view role)
       listDirectory: async (path, options, context) => {
         authorizeRequest(context, currentMetadata.sharing, "view");
@@ -871,27 +999,6 @@ async function registerMachineService(server, machineId, metadata, daemonState,
   };
 }
 
-function isStructuredMessage(msg) {
-  return !!(msg.from && msg.subject);
-}
-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}"`);
-  return `<svamp-message ${attrs.join(" ")}>
-${msg.body}
-</svamp-message>`;
-}
 function loadMessages(messagesDir, sessionId) {
   const filePath = join$1(messagesDir, "messages.jsonl");
   if (!existsSync(filePath)) return [];
@@ -1268,24 +1375,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,86 +1383,6 @@ function createSessionStore(server, sessionId, initialMetadata, initialAgentStat
       }
       return await callbacks.onApplySystemPrompt(prompt);
     },
-    // ── Inbox Messaging ──
-    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 }
-      });
-      callbacks.onInboxMessage?.(message);
-      return { messageId: message.messageId, delivered: true };
-    },
-    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 };
-    },
-    markInboxRead: async (messageIds, 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 };
-    },
-    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 };
-      } else {
-        removed = currentInbox.length;
-        metadata = { ...metadata, inbox: void 0 };
-      }
-      if (removed > 0) {
-        metadataVersion++;
-        notifyListeners({
-          type: "update-session",
-          sessionId,
-          metadata: { value: metadata, version: metadataVersion }
-        });
-      }
-      return { removed };
-    },
     // ── Listener Registration ──
     registerListener: async (callback, context) => {
       authorizeRequest(context, metadata.sharing, "view");
@@ -4971,16 +4980,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 +5656,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 +5697,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 +5772,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 +5809,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 +6034,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) {
@@ -6334,7 +6339,7 @@ The automated loop has finished. Review the progress above and let me know if yo
                 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 +6450,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 +6488,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 +6570,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 +6592,14 @@ The automated loop has finished. Review the progress above and let me know if yo
               lastSpawnMeta = { ...lastSpawnMeta, appendSystemPrompt: prompt };
               return await restartClaudeHandler();
             },
-            onInboxMessage: (message) => {
-              const xmlText = formatInboxMessageXml(message);
-              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);
-                } 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);
-                }
-              }
-            },
             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 +6615,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 +6739,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 +6770,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 +6781,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,20 +6918,20 @@ 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;
@@ -7064,10 +6988,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 +6995,14 @@ 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);
             },
             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 +7016,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 +7143,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 +7166,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 +7234,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 +7311,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 +7532,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
           });