svamp-cli 0.1.62 → 0.1.64

package/dist/{run-Bds_JVXp.mjs → run-BImPgXHd.mjs}

@@ -1,6 +1,6 @@
 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, unlink } from 'fs/promises';
-import { readFileSync as readFileSync$1, mkdirSync, writeFileSync, existsSync as existsSync$1, copyFileSync, unlinkSync, watch, rmdirSync } from 'fs';
+import fs, { mkdir as mkdir$1, readdir, readFile, writeFile, 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 { fileURLToPath } from 'url';
 import { spawn as spawn$1 } from 'child_process';
@@ -70,7 +70,7 @@ const ISOLATION_PREFERENCE = ["nono", "docker", "podman"];
 
 function resolveRoleLevel(sharing, userEmail) {
   let level = -1;
-  if (userEmail) {
+  if (userEmail && Array.isArray(sharing.allowedUsers)) {
     const sharedUser = sharing.allowedUsers.find(
       (u) => u.email.toLowerCase() === userEmail.toLowerCase()
     );
@@ -303,7 +303,10 @@ function loadPersistedMachineMetadata(svampHomeDir) {
 function savePersistedMachineMetadata(svampHomeDir, data) {
   try {
     mkdirSync(svampHomeDir, { recursive: true });
-    writeFileSync(getMachineMetadataPath(svampHomeDir), JSON.stringify(data, null, 2));
+    const filePath = getMachineMetadataPath(svampHomeDir);
+    const tmpPath = filePath + ".tmp";
+    writeFileSync(tmpPath, JSON.stringify(data, null, 2));
+    renameSync(tmpPath, filePath);
   } catch (err) {
     console.error("[HYPHA MACHINE] Failed to persist machine metadata:", err);
   }
@@ -313,9 +316,36 @@ async function registerMachineService(server, machineId, metadata, daemonState,
   let currentDaemonState = { ...daemonState };
   let metadataVersion = 1;
   let daemonStateVersion = 1;
-  const subscribers = /* @__PURE__ */ new Set();
-  const notifySubscribers = (update) => {
-    for (const push of subscribers) push(update);
+  const listeners = [];
+  const removeListener = (listener, reason) => {
+    const idx = listeners.indexOf(listener);
+    if (idx >= 0) {
+      listeners.splice(idx, 1);
+      console.log(`[HYPHA MACHINE] Listener removed (${reason}), remaining: ${listeners.length}`);
+      const rintfId = listener._rintf_service_id;
+      if (rintfId) {
+        server.unregisterService(rintfId).catch(() => {
+        });
+      }
+    }
+  };
+  const notifyListeners = (update) => {
+    const snapshot = [...listeners];
+    for (let i = snapshot.length - 1; i >= 0; i--) {
+      const listener = snapshot[i];
+      try {
+        const result = listener.onUpdate(update);
+        if (result && typeof result.catch === "function") {
+          result.catch((err) => {
+            console.error(`[HYPHA MACHINE] Async listener error:`, err);
+            removeListener(listener, "async error");
+          });
+        }
+      } catch (err) {
+        console.error(`[HYPHA MACHINE] Listener error:`, err);
+        removeListener(listener, "sync error");
+      }
+    }
   };
   const serviceInfo = await server.registerService(
     {
@@ -335,11 +365,14 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         };
       },
       // Heartbeat
-      heartbeat: async (context) => ({
-        time: Date.now(),
-        status: currentDaemonState.status,
-        machineId
-      }),
+      heartbeat: async (context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        return {
+          time: Date.now(),
+          status: currentDaemonState.status,
+          machineId
+        };
+      },
       // List active sessions on this machine
       listSessions: async (context) => {
         authorizeRequest(context, currentMetadata.sharing, "view");
@@ -401,7 +434,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           machineId
         });
         if (result.type === "success" && result.sessionId) {
-          notifySubscribers({
+          notifyListeners({
             type: "new-session",
             sessionId: result.sessionId,
             machineId
@@ -414,7 +447,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
       stopSession: async (sessionId, context) => {
         authorizeRequest(context, currentMetadata.sharing, "admin");
         const result = handlers.stopSession(sessionId);
-        notifySubscribers({
+        notifyListeners({
           type: "session-stopped",
           sessionId,
           machineId
@@ -423,7 +456,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
       },
       // Restart agent process in a session (machine-level fallback)
       restartSession: async (sessionId, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "interact");
+        authorizeRequest(context, currentMetadata.sharing, "admin");
         return await handlers.restartSession(sessionId);
       },
       // Stop the daemon
@@ -455,7 +488,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           sharing: currentMetadata.sharing,
           securityContextConfig: currentMetadata.securityContextConfig
         });
-        notifySubscribers({
+        notifyListeners({
           type: "update-machine",
           machineId,
           metadata: { value: currentMetadata, version: metadataVersion }
@@ -485,7 +518,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         }
         currentDaemonState = newState;
         daemonStateVersion++;
-        notifySubscribers({
+        notifyListeners({
           type: "update-machine",
           machineId,
           daemonState: { value: currentDaemonState, version: daemonStateVersion }
@@ -515,7 +548,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           sharing: currentMetadata.sharing,
           securityContextConfig: currentMetadata.securityContextConfig
         });
-        notifySubscribers({
+        notifyListeners({
           type: "update-machine",
           machineId,
           metadata: { value: currentMetadata, version: metadataVersion }
@@ -536,48 +569,18 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           sharing: currentMetadata.sharing,
           securityContextConfig: currentMetadata.securityContextConfig
         });
-        notifySubscribers({
+        notifyListeners({
           type: "update-machine",
           machineId,
           metadata: { value: currentMetadata, version: metadataVersion }
         });
         return { success: true };
       },
-      // Live update stream — yields machine state changes as they happen.
-      // Frontend iterates with `for await (const update of machine.subscribe())`.
-      subscribe: async function* (context) {
+      // Register a listener for real-time updates (app calls this with _rintf callback)
+      registerListener: async (callback, context) => {
         authorizeRequest(context, currentMetadata.sharing, "view");
-        const pending = [];
-        let wake = null;
-        const push = (update) => {
-          pending.push(update);
-          wake?.();
-        };
-        subscribers.add(push);
-        console.log(`[HYPHA MACHINE] subscribe() started (total: ${subscribers.size})`);
-        try {
-          yield {
-            type: "update-machine",
-            machineId,
-            metadata: { value: currentMetadata, version: metadataVersion },
-            daemonState: { value: currentDaemonState, version: daemonStateVersion }
-          };
-          while (true) {
-            while (pending.length === 0) {
-              await new Promise((r) => {
-                wake = r;
-              });
-              wake = null;
-            }
-            while (pending.length > 0) {
-              yield pending.shift();
-            }
-          }
-        } finally {
-          subscribers.delete(push);
-          wake?.();
-          console.log(`[HYPHA MACHINE] subscribe() ended (remaining: ${subscribers.size})`);
-        }
+        listeners.push(callback);
+        return { success: true, listenerId: listeners.length - 1 };
       },
       // Shell access
       bash: async (command, cwd, context) => {
@@ -603,7 +606,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         const targetPath = resolve(path || homedir());
         const home = homedir();
         const isOwner = !currentMetadata.sharing?.enabled || context?.user?.email && currentMetadata.sharing.owner && context.user.email.toLowerCase() === currentMetadata.sharing.owner.toLowerCase();
-        if (!isOwner && !targetPath.startsWith(home)) {
+        if (!isOwner && targetPath !== home && !targetPath.startsWith(home + "/")) {
           throw new Error(`Access denied: path must be within ${home}`);
         }
         const showHidden = options?.showHidden ?? false;
@@ -644,7 +647,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
       },
       /** Add and start a new supervised process. */
       processAdd: async (params, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "interact");
+        authorizeRequest(context, currentMetadata.sharing, "admin");
         if (!handlers.supervisor) throw new Error("Process supervisor not available");
         return handlers.supervisor.add(params.spec);
       },
@@ -653,7 +656,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
        * Returns { action: 'created'|'updated'|'no-change', info: ProcessInfo }
        */
       processApply: async (params, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "interact");
+        authorizeRequest(context, currentMetadata.sharing, "admin");
         if (!handlers.supervisor) throw new Error("Process supervisor not available");
         return handlers.supervisor.apply(params.spec);
       },
@@ -662,7 +665,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
        * Returns updated ProcessInfo.
        */
       processUpdate: async (params, context) => {
-        authorizeRequest(context, currentMetadata.sharing, "interact");
+        authorizeRequest(context, currentMetadata.sharing, "admin");
         if (!handlers.supervisor) throw new Error("Process supervisor not available");
         return handlers.supervisor.update(params.idOrName, params.spec);
       },
@@ -707,7 +710,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
       serviceList: async (context) => {
         authorizeRequest(context, currentMetadata.sharing, "view");
         try {
-          const { listServiceGroups } = await import('./api-Cegey1dh.mjs');
+          const { listServiceGroups } = await import('./api-BRbsyqJ4.mjs');
           return await listServiceGroups();
         } catch (err) {
           return [];
@@ -716,13 +719,13 @@ async function registerMachineService(server, machineId, metadata, daemonState,
       /** Get full details of a single service group (includes backends + health). */
       serviceGet: async (params, context) => {
         authorizeRequest(context, currentMetadata.sharing, "view");
-        const { getServiceGroup } = await import('./api-Cegey1dh.mjs');
+        const { getServiceGroup } = await import('./api-BRbsyqJ4.mjs');
         return getServiceGroup(params.name);
       },
       /** Delete a service group. */
       serviceDelete: async (params, context) => {
         authorizeRequest(context, currentMetadata.sharing, "admin");
-        const { deleteServiceGroup } = await import('./api-Cegey1dh.mjs');
+        const { deleteServiceGroup } = await import('./api-BRbsyqJ4.mjs');
         return deleteServiceGroup(params.name);
       },
       // WISE voice — create ephemeral token for OpenAI Realtime API
@@ -733,19 +736,27 @@ async function registerMachineService(server, machineId, metadata, daemonState,
           return { success: false, error: "No OpenAI API key found. Set OPENAI_API_KEY or pass apiKey." };
         }
         try {
-          const response = await fetch("https://api.openai.com/v1/realtime/client_secrets", {
-            method: "POST",
-            headers: {
-              "Authorization": `Bearer ${apiKey}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              session: {
-                type: "realtime",
-                model: params.model || "gpt-realtime-mini"
-              }
-            })
-          });
+          const wisCtrl = new AbortController();
+          const wisTimer = setTimeout(() => wisCtrl.abort(), 15e3);
+          let response;
+          try {
+            response = await fetch("https://api.openai.com/v1/realtime/client_secrets", {
+              method: "POST",
+              headers: {
+                "Authorization": `Bearer ${apiKey}`,
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify({
+                session: {
+                  type: "realtime",
+                  model: params.model || "gpt-realtime-mini"
+                }
+              }),
+              signal: wisCtrl.signal
+            });
+          } finally {
+            clearTimeout(wisTimer);
+          }
           if (!response.ok) {
             return { success: false, error: `OpenAI API error: ${response.status}` };
           }
@@ -764,7 +775,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
     updateMetadata: (newMetadata) => {
       currentMetadata = newMetadata;
       metadataVersion++;
-      notifySubscribers({
+      notifyListeners({
         type: "update-machine",
         machineId,
         metadata: { value: currentMetadata, version: metadataVersion }
@@ -773,13 +784,17 @@ async function registerMachineService(server, machineId, metadata, daemonState,
     updateDaemonState: (newState) => {
       currentDaemonState = newState;
       daemonStateVersion++;
-      notifySubscribers({
+      notifyListeners({
         type: "update-machine",
         machineId,
         daemonState: { value: currentDaemonState, version: daemonStateVersion }
       });
     },
     disconnect: async () => {
+      const toRemove = [...listeners];
+      for (const listener of toRemove) {
+        removeListener(listener, "disconnect");
+      }
       await server.unregisterService(serviceInfo.id);
     }
   };
@@ -797,17 +812,21 @@ function loadMessages(messagesDir, sessionId) {
       } catch {
       }
     }
-    return messages.slice(-5e3);
+    return messages.slice(-1e3);
   } catch {
     return [];
   }
 }
 function appendMessage(messagesDir, sessionId, msg) {
-  const filePath = join$1(messagesDir, "messages.jsonl");
-  if (!existsSync(messagesDir)) {
-    mkdirSync$1(messagesDir, { recursive: true });
+  try {
+    const filePath = join$1(messagesDir, "messages.jsonl");
+    if (!existsSync(messagesDir)) {
+      mkdirSync$1(messagesDir, { recursive: true });
+    }
+    appendFileSync(filePath, JSON.stringify(msg) + "\n");
+  } catch (err) {
+    console.error(`[HYPHA SESSION ${sessionId}] Failed to persist message: ${err?.message ?? err}`);
   }
-  appendFileSync(filePath, JSON.stringify(msg) + "\n");
 }
 async function registerSessionService(server, sessionId, initialMetadata, initialAgentState, callbacks, options) {
   const messages = options?.messagesDir ? loadMessages(options.messagesDir) : [];
@@ -822,9 +841,36 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
     mode: "remote",
     time: Date.now()
   };
-  const subscribers = /* @__PURE__ */ new Set();
-  const notifySubscribers = (update) => {
-    for (const push of subscribers) push(update);
+  const listeners = [];
+  const removeListener = (listener, reason) => {
+    const idx = listeners.indexOf(listener);
+    if (idx >= 0) {
+      listeners.splice(idx, 1);
+      console.log(`[HYPHA SESSION ${sessionId}] Listener removed (${reason}), remaining: ${listeners.length}`);
+      const rintfId = listener._rintf_service_id;
+      if (rintfId) {
+        server.unregisterService(rintfId).catch(() => {
+        });
+      }
+    }
+  };
+  const notifyListeners = (update) => {
+    const snapshot = [...listeners];
+    for (let i = snapshot.length - 1; i >= 0; i--) {
+      const listener = snapshot[i];
+      try {
+        const result = listener.onUpdate(update);
+        if (result && typeof result.catch === "function") {
+          result.catch((err) => {
+            console.error(`[HYPHA SESSION ${sessionId}] Async listener error:`, err);
+            removeListener(listener, "async error");
+          });
+        }
+      } catch (err) {
+        console.error(`[HYPHA SESSION ${sessionId}] Listener error:`, err);
+        removeListener(listener, "sync error");
+      }
+    }
   };
   const pushMessage = (content, role = "agent") => {
     let wrappedContent;
@@ -855,7 +901,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
     if (options?.messagesDir) {
       appendMessage(options.messagesDir, sessionId, msg);
     }
-    notifySubscribers({
+    notifyListeners({
       type: "new-message",
       sessionId,
       message: msg
@@ -916,7 +962,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         if (options?.messagesDir) {
           appendMessage(options.messagesDir, sessionId, msg);
         }
-        notifySubscribers({
+        notifyListeners({
           type: "new-message",
           sessionId,
           message: msg
@@ -943,7 +989,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         }
         metadata = newMetadata;
         metadataVersion++;
-        notifySubscribers({
+        notifyListeners({
           type: "update-session",
           sessionId,
           metadata: { value: metadata, version: metadataVersion }
@@ -961,7 +1007,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
        * Null values remove keys from the config.
        */
       updateConfig: async (patch, context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
+        authorizeRequest(context, metadata.sharing, "admin");
         callbacks.onUpdateConfig?.(patch);
         return { success: true };
       },
@@ -984,7 +1030,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         }
         agentState = newState;
         agentStateVersion++;
-        notifySubscribers({
+        notifyListeners({
           type: "update-session",
           sessionId,
           agentState: { value: agentState, version: agentStateVersion }
@@ -1007,7 +1053,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         return { success: true };
       },
       switchMode: async (mode, context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
+        authorizeRequest(context, metadata.sharing, "admin");
         callbacks.onSwitchMode(mode);
         return { success: true };
       },
@@ -1022,16 +1068,18 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
       },
       // ── Activity ──
       keepAlive: async (thinking, mode, context) => {
+        authorizeRequest(context, metadata.sharing, "interact");
         lastActivity = { active: true, thinking: thinking || false, mode: mode || "remote", time: Date.now() };
-        notifySubscribers({
+        notifyListeners({
           type: "activity",
           sessionId,
           ...lastActivity
         });
       },
       sessionEnd: async (context) => {
+        authorizeRequest(context, metadata.sharing, "interact");
         lastActivity = { active: false, thinking: false, mode: "remote", time: Date.now() };
-        notifySubscribers({
+        notifyListeners({
           type: "activity",
           sessionId,
           ...lastActivity
@@ -1092,6 +1140,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
       },
       /** Returns the caller's effective role (null if no access). Does not throw. */
       getEffectiveRole: async (context) => {
+        authorizeRequest(context, metadata.sharing, "view");
         const role = getEffectiveRole(context, metadata.sharing);
         return { role };
       },
@@ -1105,7 +1154,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         }
         metadata = { ...metadata, sharing: newSharing };
         metadataVersion++;
-        notifySubscribers({
+        notifyListeners({
           type: "update-session",
           sessionId,
           metadata: { value: metadata, version: metadataVersion }
@@ -1123,7 +1172,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         }
         metadata = { ...metadata, securityContext: newSecurityContext };
         metadataVersion++;
-        notifySubscribers({
+        notifyListeners({
           type: "update-session",
           sessionId,
           metadata: { value: metadata, version: metadataVersion }
@@ -1138,55 +1187,69 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         }
         return await callbacks.onApplySystemPrompt(prompt);
       },
-      // ── Live Update Stream ──
-      //
-      // Returns an async generator that yields real-time updates for this session.
-      // hypha-rpc proxies the generator across the RPC boundary — the frontend
-      // iterates with `for await (const update of service.subscribe())`.
-      //
-      // Initial state is replayed as the first batch of yields so the frontend
-      // can reconstruct full session state without a separate RPC call.
-      // Cleanup is automatic: when the frontend disconnects, hypha-rpc calls the
-      // generator's close method, triggering the finally block which removes the
-      // subscriber. No reverse `_rintf` service is registered.
-      subscribe: async function* (context) {
+      // ── Listener Registration ──
+      registerListener: async (callback, context) => {
         authorizeRequest(context, metadata.sharing, "view");
-        const pending = [];
-        let wake = null;
-        const push = (update) => {
-          pending.push(update);
-          wake?.();
-        };
-        subscribers.add(push);
-        console.log(`[HYPHA SESSION ${sessionId}] subscribe() started (total: ${subscribers.size})`);
+        listeners.push(callback);
+        const replayMessages = messages.slice(-50);
+        const REPLAY_MESSAGE_TIMEOUT_MS = 1e4;
+        for (const msg of replayMessages) {
+          if (listeners.indexOf(callback) < 0) break;
+          try {
+            const result = callback.onUpdate({
+              type: "new-message",
+              sessionId,
+              message: msg
+            });
+            if (result && typeof result.catch === "function") {
+              try {
+                await Promise.race([
+                  result,
+                  new Promise(
+                    (_, reject) => setTimeout(() => reject(new Error("Replay message timeout")), REPLAY_MESSAGE_TIMEOUT_MS)
+                  )
+                ]);
+              } catch (err) {
+                console.error(`[HYPHA SESSION ${sessionId}] Replay listener error, removing:`, err?.message ?? err);
+                removeListener(callback, "replay error");
+                return { success: false, error: "Listener removed during replay" };
+              }
+            }
+          } catch (err) {
+            console.error(`[HYPHA SESSION ${sessionId}] Replay listener error, removing:`, err?.message ?? err);
+            removeListener(callback, "replay error");
+            return { success: false, error: "Listener removed during replay" };
+          }
+        }
+        if (listeners.indexOf(callback) < 0) {
+          return { success: false, error: "Listener was removed during replay" };
+        }
         try {
-          yield {
+          const result = callback.onUpdate({
             type: "update-session",
             sessionId,
             metadata: { value: metadata, version: metadataVersion },
             agentState: { value: agentState, version: agentStateVersion }
-          };
-          const MAX_REPLAY = 50;
-          for (const msg of messages.slice(-MAX_REPLAY)) {
-            yield { type: "new-message", sessionId, message: msg };
+          });
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
           }
-          yield { type: "activity", sessionId, ...lastActivity };
-          while (true) {
-            while (pending.length === 0) {
-              await new Promise((r) => {
-                wake = r;
-              });
-              wake = null;
-            }
-            while (pending.length > 0) {
-              yield pending.shift();
-            }
+        } catch {
+        }
+        try {
+          const result = callback.onUpdate({
+            type: "activity",
+            sessionId,
+            ...lastActivity
+          });
+          if (result && typeof result.catch === "function") {
+            result.catch(() => {
+            });
           }
-        } finally {
-          subscribers.delete(push);
-          wake?.();
-          console.log(`[HYPHA SESSION ${sessionId}] subscribe() ended (remaining: ${subscribers.size})`);
+        } catch {
         }
+        return { success: true, listenerId: listeners.length - 1 };
       }
     },
     { overwrite: true }
@@ -1201,7 +1264,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
     updateMetadata: (newMetadata) => {
       metadata = newMetadata;
       metadataVersion++;
-      notifySubscribers({
+      notifyListeners({
         type: "update-session",
         sessionId,
         metadata: { value: metadata, version: metadataVersion }
@@ -1210,7 +1273,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
     updateAgentState: (newAgentState) => {
       agentState = newAgentState;
       agentStateVersion++;
-      notifySubscribers({
+      notifyListeners({
         type: "update-session",
         sessionId,
         agentState: { value: agentState, version: agentStateVersion }
@@ -1218,7 +1281,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
     },
     sendKeepAlive: (thinking, mode) => {
       lastActivity = { active: true, thinking: thinking || false, mode: mode || "remote", time: Date.now() };
-      notifySubscribers({
+      notifyListeners({
         type: "activity",
         sessionId,
         ...lastActivity
@@ -1226,7 +1289,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
     },
     sendSessionEnd: () => {
       lastActivity = { active: false, thinking: false, mode: "remote", time: Date.now() };
-      notifySubscribers({
+      notifyListeners({
         type: "activity",
         sessionId,
         ...lastActivity
@@ -1242,12 +1305,16 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         } catch {
         }
       }
-      notifySubscribers({
+      notifyListeners({
         type: "clear-messages",
         sessionId
       });
     },
     disconnect: async () => {
+      const toRemove = [...listeners];
+      for (const listener of toRemove) {
+        removeListener(listener, "disconnect");
+      }
       await server.unregisterService(serviceInfo.id);
     }
   };
@@ -1382,6 +1449,19 @@ class SessionArtifactSync {
       this.log(`[ARTIFACT SYNC] Created new collection: ${this.collectionId}`);
     }
   }
+  /**
+   * fetch() with an AbortSignal-based timeout to prevent indefinite hangs
+   * on slow/stalled presigned URL servers.
+   */
+  async fetchWithTimeout(url, options = {}, timeoutMs = 6e4) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      return await fetch(url, { ...options, signal: controller.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   /**
    * Upload a file to an artifact using the presigned URL pattern:
    * 1. put_file() returns a presigned upload URL
@@ -1396,11 +1476,11 @@ class SessionArtifactSync {
     if (!putUrl || typeof putUrl !== "string") {
       throw new Error(`put_file returned invalid URL for ${filePath}: ${putUrl}`);
     }
-    const resp = await fetch(putUrl, {
+    const resp = await this.fetchWithTimeout(putUrl, {
       method: "PUT",
       body: content,
       headers: { "Content-Type": "application/octet-stream" }
-    });
+    }, 12e4);
     if (!resp.ok) {
       throw new Error(`Upload failed for ${filePath}: ${resp.status} ${resp.statusText}`);
     }
@@ -1417,7 +1497,7 @@ class SessionArtifactSync {
       _rkwargs: true
     });
     if (!getUrl || typeof getUrl !== "string") return null;
-    const resp = await fetch(getUrl);
+    const resp = await this.fetchWithTimeout(getUrl, {}, 6e4);
     if (!resp.ok) return null;
     return await resp.text();
   }
@@ -1435,16 +1515,27 @@ class SessionArtifactSync {
       const artifactAlias = `session-${sessionId}`;
       const sessionJsonPath = join$1(sessionsDir, "session.json");
       const messagesPath = join$1(sessionsDir, "messages.jsonl");
-      const sessionData = existsSync(sessionJsonPath) ? JSON.parse(readFileSync(sessionJsonPath, "utf-8")) : null;
+      let sessionData = null;
+      if (existsSync(sessionJsonPath)) {
+        try {
+          sessionData = JSON.parse(readFileSync(sessionJsonPath, "utf-8"));
+        } catch {
+        }
+      }
       const messagesExist = existsSync(messagesPath);
       const messageCount = messagesExist ? readFileSync(messagesPath, "utf-8").split("\n").filter((l) => l.trim()).length : 0;
       let artifactId;
+      let existingArtifactId = null;
       try {
         const existing = await this.artifactManager.read({
           artifact_id: artifactAlias,
           _rkwargs: true
         });
-        artifactId = existing.id;
+        existingArtifactId = existing.id;
+      } catch {
+      }
+      if (existingArtifactId) {
+        artifactId = existingArtifactId;
         await this.artifactManager.edit({
           artifact_id: artifactId,
           manifest: {
@@ -1458,7 +1549,7 @@ class SessionArtifactSync {
           stage: true,
           _rkwargs: true
         });
-      } catch {
+      } else {
         const artifact = await this.artifactManager.create({
           alias: artifactAlias,
           parent_id: this.collectionId,
@@ -1512,6 +1603,16 @@ class SessionArtifactSync {
     }, delayMs);
     this.syncTimers.set(sessionId, timer);
   }
+  /**
+   * Cancel any pending debounced sync for a session (e.g., when session is stopped).
+   */
+  cancelSync(sessionId) {
+    const existing = this.syncTimers.get(sessionId);
+    if (existing) {
+      clearTimeout(existing);
+      this.syncTimers.delete(sessionId);
+    }
+  }
   /**
    * Download a session from artifact store to local disk.
    */
@@ -1879,6 +1980,7 @@ function completeToolCall(toolCallId, toolKind, content, ctx) {
   const toolKindStr = typeof toolKind === "string" ? toolKind : "unknown";
   ctx.activeToolCalls.delete(toolCallId);
   ctx.toolCallStartTimes.delete(toolCallId);
+  ctx.toolCallIdToNameMap.delete(toolCallId);
   const timeout = ctx.toolCallTimeouts.get(toolCallId);
   if (timeout) {
     clearTimeout(timeout);
@@ -1888,7 +1990,12 @@ function completeToolCall(toolCallId, toolKind, content, ctx) {
   ctx.emit({ type: "tool-result", toolName: toolKindStr, result: content, callId: toolCallId });
   if (ctx.activeToolCalls.size === 0) {
     ctx.clearIdleTimeout();
-    ctx.emitIdleStatus();
+    const idleTimeoutMs = ctx.transport.getIdleTimeout?.() ?? DEFAULT_IDLE_TIMEOUT_MS;
+    ctx.setIdleTimeout(() => {
+      if (ctx.activeToolCalls.size === 0) {
+        ctx.emitIdleStatus();
+      }
+    }, idleTimeoutMs);
   }
 }
 function failToolCall(toolCallId, status, toolKind, content, ctx) {
@@ -1897,6 +2004,7 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   const toolKindStr = typeof toolKind === "string" ? toolKind : "unknown";
   ctx.activeToolCalls.delete(toolCallId);
   ctx.toolCallStartTimes.delete(toolCallId);
+  ctx.toolCallIdToNameMap.delete(toolCallId);
   const timeout = ctx.toolCallTimeouts.get(toolCallId);
   if (timeout) {
     clearTimeout(timeout);
@@ -1912,7 +2020,12 @@ function failToolCall(toolCallId, status, toolKind, content, ctx) {
   });
   if (ctx.activeToolCalls.size === 0) {
     ctx.clearIdleTimeout();
-    ctx.emitIdleStatus();
+    const idleTimeoutMs = ctx.transport.getIdleTimeout?.() ?? DEFAULT_IDLE_TIMEOUT_MS;
+    ctx.setIdleTimeout(() => {
+      if (ctx.activeToolCalls.size === 0) {
+        ctx.emitIdleStatus();
+      }
+    }, idleTimeoutMs);
   }
 }
 function handleToolCallUpdate(update, ctx) {
@@ -2161,10 +2274,22 @@ class AcpBackend {
         this.emit({ type: "status", status: "error", detail: err.message });
       });
       this.process.on("exit", (code, signal) => {
-        if (!this.disposed && code !== 0 && code !== null) {
+        if (this.disposed) return;
+        if (code !== 0 && code !== null) {
           signalStartupFailure(new Error(`Exit code: ${code}`));
           this.log(`[ACP] Process exited: code=${code}, signal=${signal}`);
           this.emit({ type: "status", status: "stopped", detail: `Exit code: ${code}` });
+        } else if (code === null && this.waitingForResponse) {
+          this.log(`[ACP] Process killed by signal: ${signal} (mid-turn)`);
+          this.waitingForResponse = false;
+          if (this.idleResolver) {
+            this.idleResolver();
+            this.idleResolver = null;
+          }
+          this.emit({ type: "status", status: "stopped", detail: `Process killed by signal: ${signal}` });
+        } else if (code === 0 && this.waitingForResponse) {
+          this.log(`[ACP] Process exited cleanly but response was pending \u2014 emitting idle`);
+          this.emitIdleStatus();
         }
       });
       const streams = nodeToWebStreams(this.process.stdin, this.process.stdout);
@@ -2319,12 +2444,14 @@ class AcpBackend {
         const maybeErr = error;
         if (startupFailure && error === startupFailure) return true;
         if (maybeErr.code === "ENOENT" || maybeErr.code === "EACCES" || maybeErr.code === "EPIPE") return true;
+        if (maybeErr.code === "DISPOSED") return true;
         const msg = error.message.toLowerCase();
         if (msg.includes("api key") || msg.includes("not configured") || msg.includes("401") || msg.includes("403")) return true;
         return false;
       };
       await withRetry(
         async () => {
+          if (this.disposed) throw Object.assign(new Error("Backend disposed during startup retry"), { code: "DISPOSED" });
           let timeoutHandle = null;
           try {
             const result = await Promise.race([
@@ -2375,6 +2502,7 @@ class AcpBackend {
       this.log(`[ACP] Creating new session...`);
       const sessionResponse = await withRetry(
         async () => {
+          if (this.disposed) throw Object.assign(new Error("Backend disposed during startup retry"), { code: "DISPOSED" });
           let timeoutHandle = null;
           try {
             const result = await Promise.race([
@@ -2524,9 +2652,16 @@ class AcpBackend {
     handleThinkingUpdate(update, ctx);
   }
   emitIdleStatus() {
+    const resolver = this.idleResolver;
+    this.idleResolver = null;
+    this.waitingForResponse = false;
     this.emit({ type: "status", status: "idle" });
-    if (this.idleResolver) {
-      this.idleResolver();
+    if (resolver) {
+      const newPromptInFlight = this.waitingForResponse;
+      resolver();
+      if (newPromptInFlight) {
+        this.waitingForResponse = true;
+      }
     }
   }
   async sendPrompt(sessionId, prompt) {
@@ -2580,9 +2715,14 @@ class AcpBackend {
   }
   async cancel(sessionId) {
     if (!this.connection || !this.acpSessionId) return;
+    this.waitingForResponse = false;
+    if (this.idleResolver) {
+      this.idleResolver();
+      this.idleResolver = null;
+    }
     try {
       await this.connection.cancel({ sessionId: this.acpSessionId });
-      this.emit({ type: "status", status: "stopped", detail: "Cancelled by user" });
+      this.emit({ type: "status", status: "cancelled", detail: "Cancelled by user" });
     } catch (error) {
       this.log("[ACP] Error cancelling:", error);
     }
@@ -2605,16 +2745,24 @@ class AcpBackend {
       }
     }
     if (this.process) {
-      this.process.kill("SIGTERM");
+      try {
+        this.process.kill("SIGTERM");
+      } catch {
+      }
       await new Promise((resolve) => {
         const timeout = setTimeout(() => {
-          if (this.process) this.process.kill("SIGKILL");
+          try {
+            if (this.process) this.process.kill("SIGKILL");
+          } catch {
+          }
           resolve();
         }, 1e3);
-        this.process?.once("exit", () => {
+        const done = () => {
           clearTimeout(timeout);
           resolve();
-        });
+        };
+        this.process?.once("exit", done);
+        this.process?.once("close", done);
       });
       this.process = null;
     }
@@ -2629,6 +2777,7 @@ class AcpBackend {
     for (const timeout of this.toolCallTimeouts.values()) clearTimeout(timeout);
     this.toolCallTimeouts.clear();
     this.toolCallStartTimes.clear();
+    this.toolCallIdToNameMap.clear();
   }
 }
 
@@ -2694,6 +2843,7 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
   let pendingText = "";
   let turnText = "";
   let flushTimer = null;
+  let bridgeStopped = false;
   function flushText() {
     if (pendingText) {
       sessionService.pushMessage({
@@ -2708,6 +2858,7 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
     }
   }
   backend.onMessage((msg) => {
+    if (bridgeStopped) return;
     switch (msg.type) {
       case "model-output": {
         if (msg.textDelta) {
@@ -2739,6 +2890,7 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
           setMetadata((m) => ({ ...m, lifecycleState: "running" }));
         } else if (msg.status === "error") {
           flushText();
+          turnText = "";
           sessionService.pushMessage(
             { type: "message", message: `Agent process exited unexpectedly: ${msg.detail || "Unknown error"}` },
             "event"
@@ -2747,8 +2899,12 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
           setMetadata((m) => ({ ...m, lifecycleState: "error" }));
         } else if (msg.status === "stopped") {
           flushText();
+          turnText = "";
           sessionService.sendSessionEnd();
           setMetadata((m) => ({ ...m, lifecycleState: "stopped" }));
+        } else if (msg.status === "cancelled") {
+          flushText();
+          turnText = "";
         }
         break;
       }
@@ -2829,6 +2985,14 @@ function bridgeAcpToSession(backend, sessionService, getMetadata, setMetadata, l
       }
     }
   });
+  return () => {
+    bridgeStopped = true;
+    if (flushTimer) {
+      clearTimeout(flushTimer);
+      flushTimer = null;
+    }
+    pendingText = "";
+  };
 }
 class HyphaPermissionHandler {
   constructor(shouldAutoAllow, log) {
@@ -2894,6 +3058,10 @@ class CodexMcpBackend {
   client;
   transport = null;
   disposed = false;
+  turnCancelled = false;
+  // set by cancel() to suppress 'idle' in sendPrompt() finally
+  turnId = 0;
+  // monotonically increasing; each sendPrompt() captures its own ID
   codexSessionId = null;
   conversationId = null;
   svampSessionId = null;
@@ -2945,7 +3113,10 @@ class CodexMcpBackend {
   }
   async sendPrompt(sessionId, prompt) {
     if (!this.connected) throw new Error("Codex not connected");
+    this.turnCancelled = false;
+    const myTurnId = ++this.turnId;
     this.emit({ type: "status", status: "running" });
+    let hadError = false;
     try {
       let response;
       if (this.codexSessionId) {
@@ -2966,16 +3137,20 @@ class CodexMcpBackend {
         }
       }
     } catch (err) {
+      hadError = true;
       this.log(`[Codex] Error in sendPrompt: ${err.message}`);
       this.emit({ type: "status", status: "error", detail: err.message });
       throw err;
     } finally {
-      this.emit({ type: "status", status: "idle" });
+      if (!this.turnCancelled && !hadError && this.turnId === myTurnId) {
+        this.emit({ type: "status", status: "idle" });
+      }
     }
   }
   async cancel(_sessionId) {
     this.log("[Codex] Cancel requested");
-    this.emit({ type: "status", status: "idle" });
+    this.turnCancelled = true;
+    this.emit({ type: "status", status: "cancelled" });
   }
   async respondToPermission(requestId, approved) {
     const pending = this.pendingApprovals.get(requestId);
@@ -3170,8 +3345,8 @@ class CodexMcpBackend {
         this.emit({ type: "status", status: "running" });
         break;
       case "task_complete":
+        break;
       case "turn_aborted":
-        this.emit({ type: "status", status: "idle" });
         break;
       case "agent_message": {
         const content = event.content;
@@ -3803,7 +3978,10 @@ class ProcessSupervisor {
   /** Start a stopped/failed process by id or name. */
   async start(idOrName) {
     const entry = this.require(idOrName);
-    if (entry.child && !entry.stopping) throw new Error(`Process '${entry.spec.name}' is already running`);
+    if (entry.child) {
+      if (entry.stopping) throw new Error(`Process '${entry.spec.name}' is being stopped, try again shortly`);
+      throw new Error(`Process '${entry.spec.name}' is already running`);
+    }
     entry.stopping = false;
     await this.startEntry(entry, false);
   }
@@ -3823,15 +4001,21 @@ class ProcessSupervisor {
   /** Restart a process (stop if running, then start again). */
   async restart(idOrName) {
     const entry = this.require(idOrName);
-    if (entry.child) {
-      entry.stopping = true;
-      this.clearTimers(entry);
-      await this.killChild(entry.child);
-      entry.child = void 0;
+    if (entry.restarting) return;
+    entry.restarting = true;
+    try {
+      if (entry.child) {
+        entry.stopping = true;
+        this.clearTimers(entry);
+        await this.killChild(entry.child);
+        entry.child = void 0;
+      }
+      entry.stopping = false;
+      entry.state.restartCount++;
+      await this.startEntry(entry, false);
+    } finally {
+      entry.restarting = false;
     }
-    entry.stopping = false;
-    entry.state.restartCount++;
-    await this.startEntry(entry, false);
   }
   /** Stop the process and remove it from supervision (deletes persisted spec). */
   async remove(idOrName) {
@@ -3965,7 +4149,9 @@ class ProcessSupervisor {
   }
   async persistSpec(spec) {
     const filePath = path.join(this.persistDir, `${spec.id}.json`);
-    await writeFile(filePath, JSON.stringify(spec, null, 2), "utf-8");
+    const tmpPath = filePath + ".tmp";
+    await writeFile(tmpPath, JSON.stringify(spec, null, 2), "utf-8");
+    await rename(tmpPath, filePath);
   }
   async deleteSpec(id) {
     try {
@@ -4039,7 +4225,13 @@ class ProcessSupervisor {
       };
       child.stdout?.on("data", appendLog);
       child.stderr?.on("data", appendLog);
-      child.on("exit", (code, signal) => this.onProcessExit(entry, code, signal));
+      child.on("error", (err) => {
+        console.error(`[SUPERVISOR] Process '${spec.name}' error: ${err.message}`);
+      });
+      child.on("close", (code, signal) => {
+        if (entry.child !== child) return;
+        this.onProcessExit(entry, code, signal);
+      });
       if (spec.probe) this.setupProbe(entry);
       if (spec.ttl !== void 0) this.setupTTL(entry);
       console.log(`[SUPERVISOR] Started '${spec.name}' pid=${child.pid}`);
@@ -4127,6 +4319,8 @@ class ProcessSupervisor {
     }
   }
   async triggerProbeRestart(entry) {
+    if (entry.restarting) return;
+    if (entry.stopping) return;
     console.warn(`[SUPERVISOR] Restarting '${entry.spec.name}' due to probe failures`);
     entry.state.consecutiveProbeFailures = 0;
     this.clearTimers(entry);
@@ -4151,6 +4345,7 @@ class ProcessSupervisor {
     console.log(`[SUPERVISOR] Process '${entry.spec.name}' TTL expired`);
     entry.state.status = "expired";
     entry.stopping = true;
+    this.clearTimers(entry);
     const cleanup = async () => {
       if (entry.child) await this.killChild(entry.child);
       this.entries.delete(entry.spec.id);
@@ -4162,13 +4357,36 @@ class ProcessSupervisor {
   // ── Process kill helper ───────────────────────────────────────────────────
   killChild(child) {
     return new Promise((resolve) => {
-      const done = () => resolve();
+      let resolved = false;
+      let forceKillTimer;
+      let hardDeadlineTimer;
+      const done = () => {
+        if (!resolved) {
+          resolved = true;
+          if (forceKillTimer) clearTimeout(forceKillTimer);
+          if (hardDeadlineTimer) clearTimeout(hardDeadlineTimer);
+          resolve();
+        }
+      };
       child.once("exit", done);
-      child.kill("SIGTERM");
-      const forceKill = setTimeout(() => {
-        child.kill("SIGKILL");
+      child.once("close", done);
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      forceKillTimer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+        hardDeadlineTimer = setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+            console.warn(`[SUPERVISOR] Process pid=${child.pid} did not exit after SIGKILL \u2014 forcing resolution`);
+            resolve();
+          }
+        }, 2e3);
       }, 5e3);
-      child.once("exit", () => clearTimeout(forceKill));
     });
   }
   // ── Timer cleanup ─────────────────────────────────────────────────────────
@@ -4266,7 +4484,9 @@ function readSvampConfig(configPath) {
 function writeSvampConfig(configPath, config) {
   mkdirSync(dirname(configPath), { recursive: true });
   const content = JSON.stringify(config, null, 2);
-  writeFileSync(configPath, content);
+  const tmpPath = configPath + ".tmp";
+  writeFileSync(tmpPath, content);
+  renameSync(tmpPath, configPath);
   return content;
 }
 function getRalphStateFilePath(directory, sessionId) {
@@ -4320,7 +4540,9 @@ started_at: "${state.started_at}"${lastIterLine}${contextModeLine}${originalResu
 
 ${state.task}
 `;
-  writeFileSync(filePath, content);
+  const tmpPath = `${filePath}.tmp`;
+  writeFileSync(tmpPath, content);
+  renameSync(tmpPath, filePath);
 }
 function removeRalphState(filePath) {
   try {
@@ -4409,20 +4631,17 @@ function createSvampConfigChecker(directory, sessionId, getMetadata, setMetadata
             ralphSystemPrompt: ralphSysPrompt
           }]
         }));
-        sessionService.updateMetadata(getMetadata());
         sessionService.pushMessage(
-          { type: "message", message: buildIterationStatus(1, state.max_iterations, state.completion_promise) },
+          { type: "message", message: buildIterationStatus(state.iteration + 1, state.max_iterations, state.completion_promise) },
           "event"
         );
-        logger.log(`[svampConfig] Ralph loop started: "${state.task.slice(0, 50)}..."`);
+        logger.log(`[svampConfig] Ralph loop started/resumed at iteration ${state.iteration + 1}: "${state.task.slice(0, 50)}..."`);
         onRalphLoopActivated?.();
       } else if (prevRalph.currentIteration !== ralphLoop.currentIteration || prevRalph.task !== ralphLoop.task) {
         setMetadata((m) => ({ ...m, ralphLoop }));
-        sessionService.updateMetadata(getMetadata());
       }
     } else if (prevRalph?.active) {
       setMetadata((m) => ({ ...m, ralphLoop: { active: false } }));
-      sessionService.updateMetadata(getMetadata());
       sessionService.pushMessage(
         { type: "message", message: `Ralph loop cancelled at iteration ${prevRalph.currentIteration}.` },
         "event"
@@ -4655,18 +4874,19 @@ function loadSessionIndex() {
   }
 }
 function saveSessionIndex(index) {
-  writeFileSync(SESSION_INDEX_FILE, JSON.stringify(index, null, 2), "utf-8");
+  const tmp = SESSION_INDEX_FILE + ".tmp";
+  writeFileSync(tmp, JSON.stringify(index, null, 2), "utf-8");
+  renameSync(tmp, SESSION_INDEX_FILE);
 }
 function saveSession(session) {
   const sessionDir = getSessionDir(session.directory, session.sessionId);
   if (!existsSync$1(sessionDir)) {
     mkdirSync(sessionDir, { recursive: true });
   }
-  writeFileSync(
-    getSessionFilePath(session.directory, session.sessionId),
-    JSON.stringify(session, null, 2),
-    "utf-8"
-  );
+  const filePath = getSessionFilePath(session.directory, session.sessionId);
+  const tmpPath = filePath + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(session, null, 2), "utf-8");
+  renameSync(tmpPath, filePath);
   const index = loadSessionIndex();
   index[session.sessionId] = { directory: session.directory, createdAt: session.createdAt };
   saveSessionIndex(index);
@@ -4690,6 +4910,16 @@ function deletePersistedSession(sessionId) {
       if (existsSync$1(configFile)) unlinkSync(configFile);
     } catch {
     }
+    const ralphStateFile = getRalphStateFilePath(entry.directory, sessionId);
+    try {
+      if (existsSync$1(ralphStateFile)) unlinkSync(ralphStateFile);
+    } catch {
+    }
+    const ralphProgressFile = getRalphProgressFilePath(entry.directory, sessionId);
+    try {
+      if (existsSync$1(ralphProgressFile)) unlinkSync(ralphProgressFile);
+    } catch {
+    }
     const sessionDir = getSessionDir(entry.directory, sessionId);
     try {
       rmdirSync(sessionDir);
@@ -4755,7 +4985,9 @@ function createLogger() {
 }
 function writeDaemonStateFile(state) {
   ensureHomeDir();
-  writeFileSync(DAEMON_STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
+  const tmpPath = DAEMON_STATE_FILE + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+  renameSync(tmpPath, DAEMON_STATE_FILE);
 }
 function readDaemonStateFile() {
   try {
@@ -4998,6 +5230,7 @@ async function startDaemon(options) {
       if (agentName !== "claude" && (KNOWN_ACP_AGENTS[agentName] || KNOWN_MCP_AGENTS[agentName])) {
         return await spawnAgentSession(sessionId, directory, agentName, options2, resumeSessionId);
       }
+      let stagedCredentials = null;
       try {
         let parseBashPermission2 = function(permission) {
           if (permission === "Bash") return;
@@ -5031,17 +5264,23 @@ async function startDaemon(options) {
               resolve2();
               return;
             }
+            let settled = false;
+            const done = () => {
+              if (settled) return;
+              settled = true;
+              clearTimeout(timeout);
+              proc.off("exit", exitHandler);
+              resolve2();
+            };
             const timeout = setTimeout(() => {
               try {
                 proc.kill("SIGKILL");
               } catch {
               }
-              resolve2();
+              done();
             }, timeoutMs);
-            proc.on("exit", () => {
-              clearTimeout(timeout);
-              resolve2();
-            });
+            const exitHandler = () => done();
+            proc.on("exit", exitHandler);
             if (!proc.killed) {
               proc.kill(signal);
             }
@@ -5135,6 +5374,8 @@ async function startDaemon(options) {
         let userMessagePending = false;
         let turnInitiatedByUser = true;
         let isKillingClaude = false;
+        let isRestartingClaude = false;
+        let isSwitchingMode = false;
         let checkSvampConfig;
         let cleanupSvampConfig;
         const CLAUDE_PERMISSION_MODE_MAP = {
@@ -5142,7 +5383,6 @@ async function startDaemon(options) {
         };
         const toClaudePermissionMode = (mode) => CLAUDE_PERMISSION_MODE_MAP[mode] || mode;
         let isolationCleanupFiles = [];
-        let stagedCredentials = null;
         const spawnClaude = (initialMessage, meta) => {
           const effectiveMeta = { ...lastSpawnMeta, ...meta };
           let rawPermissionMode = effectiveMeta.permissionMode || agentConfig.default_permission_mode || currentPermissionMode;
@@ -5210,12 +5450,17 @@ async function startDaemon(options) {
           });
           claudeProcess = child;
           logger.log(`[Session ${sessionId}] Claude PID: ${child.pid}, stdin: ${!!child.stdin}, stdout: ${!!child.stdout}, stderr: ${!!child.stderr}`);
+          child.stdin?.on("error", (err) => {
+            logger.log(`[Session ${sessionId}] Claude stdin error: ${err.message}`);
+          });
           child.on("error", (err) => {
             logger.log(`[Session ${sessionId}] Claude process error: ${err.message}`);
             sessionService.pushMessage(
               { type: "message", message: `Agent process exited unexpectedly: ${err.message}. Please ensure Claude Code CLI is installed.` },
               "event"
             );
+            sessionWasProcessing = false;
+            claudeProcess = null;
             signalProcessing(false);
             sessionService.sendSessionEnd();
           });
@@ -5327,7 +5572,7 @@ async function startDaemon(options) {
                     }
                     const textBlocks = assistantContent.filter((b) => b.type === "text").map((b) => b.text);
                     if (textBlocks.length > 0) {
-                      lastAssistantText = textBlocks.join("\n");
+                      lastAssistantText += textBlocks.join("\n");
                     }
                   }
                   if (msg.type === "result") {
@@ -5365,9 +5610,12 @@ async function startDaemon(options) {
                       turnInitiatedByUser = true;
                       continue;
                     }
+                    if (msg.session_id) {
+                      claudeResumeId = msg.session_id;
+                    }
                     signalProcessing(false);
                     sessionWasProcessing = false;
-                    if (claudeResumeId) {
+                    if (claudeResumeId && !trackedSession.stopped) {
                       saveSession({
                         sessionId,
                         directory,
@@ -5387,7 +5635,7 @@ async function startDaemon(options) {
                       sessionService.pushMessage({ type: "session_event", message: taskInfo }, "session");
                     }
                     const queueLen = sessionMetadata.messageQueue?.length ?? 0;
-                    if (queueLen > 0 && claudeResumeId) {
+                    if (queueLen > 0 && claudeResumeId && !trackedSession.stopped) {
                       setTimeout(() => processMessageQueueRef?.(), 200);
                     } else if (claudeResumeId) {
                       const rlState = readRalphState(getRalphStateFilePath(directory, sessionId));
@@ -5411,6 +5659,7 @@ async function startDaemon(options) {
                           logger.log(`[Session ${sessionId}] ${reason}`);
                           sessionService.pushMessage({ type: "message", message: reason }, "event");
                           if (isFreshMode && rlState.original_resume_id) {
+                            claudeResumeId = rlState.original_resume_id;
                             (async () => {
                               try {
                                 if (claudeProcess && claudeProcess.exitCode === null) {
@@ -5418,7 +5667,8 @@ async function startDaemon(options) {
                                   await killAndWaitForExit2(claudeProcess);
                                   isKillingClaude = false;
                                 }
-                                claudeResumeId = rlState.original_resume_id;
+                                if (trackedSession.stopped) return;
+                                if (isRestartingClaude || isSwitchingMode) return;
                                 const progressPath = getRalphProgressFilePath(directory, sessionId);
                                 let resumeMessage;
                                 try {
@@ -5458,7 +5708,16 @@ The automated loop has finished. Review the progress above and let me know if yo
                           if (isFreshMode && !rlState.original_resume_id && claudeResumeId) {
                             updatedRlState.original_resume_id = claudeResumeId;
                           }
-                          writeRalphState(getRalphStateFilePath(directory, sessionId), updatedRlState);
+                          try {
+                            writeRalphState(getRalphStateFilePath(directory, sessionId), updatedRlState);
+                          } catch (writeErr) {
+                            logger.log(`[Session ${sessionId}] Ralph: failed to persist state (iter ${nextIteration}): ${writeErr.message} \u2014 stopping loop`);
+                            sessionService.pushMessage({ type: "message", message: `Ralph loop error: failed to persist iteration state \u2014 loop stopped. (${writeErr.message})` }, "event");
+                            removeRalphState(getRalphStateFilePath(directory, sessionId));
+                            sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
+                            sessionService.updateMetadata(sessionMetadata);
+                            break;
+                          }
                           const ralphLoop = {
                             active: true,
                             task: rlState.task,
@@ -5478,13 +5737,15 @@ The automated loop has finished. Review the progress above and let me know if yo
                           const ralphSysPrompt = buildRalphSystemPrompt(updatedRlState, progressRelPath);
                           const cooldownMs = Math.max(200, rlState.cooldown_seconds * 1e3);
                           if (isFreshMode) {
+                            isKillingClaude = true;
                             setTimeout(async () => {
                               try {
                                 if (claudeProcess && claudeProcess.exitCode === null) {
-                                  isKillingClaude = true;
                                   await killAndWaitForExit2(claudeProcess);
-                                  isKillingClaude = false;
                                 }
+                                isKillingClaude = false;
+                                if (trackedSession.stopped) return;
+                                if (isRestartingClaude || isSwitchingMode) return;
                                 claudeResumeId = void 0;
                                 userMessagePending = true;
                                 turnInitiatedByUser = true;
@@ -5496,25 +5757,34 @@ The automated loop has finished. Review the progress above and let me know if yo
                               } catch (err) {
                                 logger.log(`[Session ${sessionId}] Error in fresh Ralph iteration: ${err.message}`);
                                 isKillingClaude = false;
+                                sessionWasProcessing = false;
                                 signalProcessing(false);
                               }
                             }, cooldownMs);
                           } else {
                             setTimeout(() => {
-                              userMessagePending = true;
-                              turnInitiatedByUser = true;
-                              sessionWasProcessing = true;
-                              signalProcessing(true);
-                              sessionService.pushMessage({ type: "message", message: buildIterationStatus(nextIteration, rlState.max_iterations, rlState.completion_promise) }, "event");
-                              sessionService.pushMessage(rlState.task, "user");
-                              if (claudeProcess && claudeProcess.exitCode === null) {
-                                const stdinMsg = JSON.stringify({
-                                  type: "user",
-                                  message: { role: "user", content: prompt }
-                                });
-                                claudeProcess.stdin?.write(stdinMsg + "\n");
-                              } else {
-                                spawnClaude(prompt, { appendSystemPrompt: ralphSysPrompt });
+                              if (trackedSession.stopped) return;
+                              if (isRestartingClaude || isSwitchingMode) return;
+                              try {
+                                userMessagePending = true;
+                                turnInitiatedByUser = true;
+                                sessionWasProcessing = true;
+                                signalProcessing(true);
+                                sessionService.pushMessage({ type: "message", message: buildIterationStatus(nextIteration, rlState.max_iterations, rlState.completion_promise) }, "event");
+                                sessionService.pushMessage(rlState.task, "user");
+                                if (claudeProcess && claudeProcess.exitCode === null) {
+                                  const stdinMsg = JSON.stringify({
+                                    type: "user",
+                                    message: { role: "user", content: prompt }
+                                  });
+                                  claudeProcess.stdin?.write(stdinMsg + "\n");
+                                } else {
+                                  spawnClaude(prompt, { appendSystemPrompt: ralphSysPrompt });
+                                }
+                              } catch (err) {
+                                logger.log(`[Session ${sessionId}] Error in continue Ralph iteration: ${err.message}`);
+                                sessionWasProcessing = false;
+                                signalProcessing(false);
                               }
                             }, cooldownMs);
                           }
@@ -5529,10 +5799,8 @@ The automated loop has finished. Review the progress above and let me know if yo
                     }
                   }
                   sessionService.pushMessage(msg, "agent");
-                  if (msg.session_id) {
-                    claudeResumeId = msg.session_id;
-                  }
                 } else if (msg.type === "system" && msg.subtype === "init") {
+                  lastAssistantText = "";
                   if (!userMessagePending) {
                     turnInitiatedByUser = false;
                     logger.log(`[Session ${sessionId}] SDK-initiated turn (likely stale task_notification)`);
@@ -5543,18 +5811,20 @@ The automated loop has finished. Review the progress above and let me know if yo
                     claudeResumeId = msg.session_id;
                     sessionMetadata = { ...sessionMetadata, claudeSessionId: msg.session_id };
                     sessionService.updateMetadata(sessionMetadata);
-                    saveSession({
-                      sessionId,
-                      directory,
-                      claudeResumeId,
-                      permissionMode: currentPermissionMode,
-                      spawnMeta: lastSpawnMeta,
-                      metadata: sessionMetadata,
-                      createdAt: Date.now(),
-                      machineId,
-                      wasProcessing: sessionWasProcessing
-                    });
-                    artifactSync.scheduleDebouncedSync(sessionId, getSessionDir(directory, sessionId), sessionMetadata, machineId);
+                    if (!trackedSession.stopped) {
+                      saveSession({
+                        sessionId,
+                        directory,
+                        claudeResumeId,
+                        permissionMode: currentPermissionMode,
+                        spawnMeta: lastSpawnMeta,
+                        metadata: sessionMetadata,
+                        createdAt: Date.now(),
+                        machineId,
+                        wasProcessing: sessionWasProcessing
+                      });
+                      artifactSync.scheduleDebouncedSync(sessionId, getSessionDir(directory, sessionId), sessionMetadata, machineId);
+                    }
                     if (isConversationClear) {
                       logger.log(`[Session ${sessionId}] Conversation cleared (/clear) \u2014 new Claude session: ${msg.session_id}`);
                       sessionService.clearMessages();
@@ -5580,6 +5850,19 @@ The automated loop has finished. Review the progress above and let me know if yo
               }
             }
           });
+          child.stdout?.on("close", () => {
+            const remaining = stdoutBuffer.trim();
+            if (remaining) {
+              logger.log(`[Session ${sessionId}] stdout close with remaining buffer (${remaining.length} chars): ${remaining.slice(0, 200)}`);
+              try {
+                const msg = JSON.parse(remaining);
+                sessionService.pushMessage(msg, "agent");
+              } catch {
+                logger.log(`[Session ${sessionId}] Discarding non-JSON stdout remainder on close`);
+              }
+              stdoutBuffer = "";
+            }
+          });
           let stderrBuffer = "";
           child.stderr?.on("data", (chunk) => {
             const text = chunk.toString();
@@ -5609,7 +5892,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             sessionService.updateMetadata(sessionMetadata);
             sessionWasProcessing = false;
             const queueLen = sessionMetadata.messageQueue?.length ?? 0;
-            if (queueLen > 0 && claudeResumeId) {
+            if (queueLen > 0 && claudeResumeId && !trackedSession.stopped) {
               signalProcessing(false);
               setTimeout(() => processMessageQueueRef?.(), 200);
             } else {
@@ -5643,6 +5926,10 @@ The automated loop has finished. Review the progress above and let me know if yo
         };
         const restartClaudeHandler = async () => {
           logger.log(`[Session ${sessionId}] Restart Claude requested`);
+          if (isRestartingClaude || isSwitchingMode) {
+            return { success: false, message: "Restart already in progress." };
+          }
+          isRestartingClaude = true;
           try {
             if (claudeProcess && claudeProcess.exitCode === null) {
               isKillingClaude = true;
@@ -5651,6 +5938,9 @@ The automated loop has finished. Review the progress above and let me know if yo
               await killAndWaitForExit2(claudeProcess);
               isKillingClaude = false;
             }
+            if (trackedSession?.stopped) {
+              return { success: false, message: "Session was stopped during restart." };
+            }
             if (claudeResumeId) {
               spawnClaude(void 0, { permissionMode: currentPermissionMode });
               logger.log(`[Session ${sessionId}] Claude respawned with --resume ${claudeResumeId}`);
@@ -5663,6 +5953,8 @@ The automated loop has finished. Review the progress above and let me know if yo
             isKillingClaude = false;
             logger.log(`[Session ${sessionId}] Restart failed: ${err.message}`);
             return { success: false, message: `Restart failed: ${err.message}` };
+          } finally {
+            isRestartingClaude = false;
           }
         };
         if (sessionMetadata.sharing?.enabled && isolationCapabilities.preferred) {
@@ -5681,6 +5973,7 @@ The automated loop has finished. Review the progress above and let me know if yo
           { controlledByUser: false },
           {
             onUserMessage: (content, meta) => {
+              if (trackedSession?.stopped) return;
               logger.log(`[Session ${sessionId}] User message received`);
               userMessagePending = true;
               turnInitiatedByUser = true;
@@ -5707,7 +6000,7 @@ The automated loop has finished. Review the progress above and let me know if yo
               if (msgMeta) {
                 lastSpawnMeta = { ...lastSpawnMeta, ...msgMeta };
               }
-              if (isKillingClaude) {
+              if (isKillingClaude || isRestartingClaude || isSwitchingMode) {
                 logger.log(`[Session ${sessionId}] Message received while restarting Claude, queuing to prevent loss`);
                 const existingQueue = sessionMetadata.messageQueue || [];
                 sessionMetadata = {
@@ -5761,6 +6054,19 @@ The automated loop has finished. Review the progress above and let me know if yo
               if (params.mode) {
                 currentPermissionMode = toClaudePermissionMode(params.mode);
                 logger.log(`[Session ${sessionId}] Permission mode changed to: ${currentPermissionMode}`);
+                if (claudeResumeId && !trackedSession.stopped) {
+                  saveSession({
+                    sessionId,
+                    directory,
+                    claudeResumeId,
+                    permissionMode: currentPermissionMode,
+                    spawnMeta: lastSpawnMeta,
+                    metadata: sessionMetadata,
+                    createdAt: Date.now(),
+                    machineId,
+                    wasProcessing: sessionWasProcessing
+                  });
+                }
               }
               if (params.allowTools && Array.isArray(params.allowTools)) {
                 for (const tool of params.allowTools) {
@@ -5791,12 +6097,23 @@ The automated loop has finished. Review the progress above and let me know if yo
             },
             onSwitchMode: async (mode) => {
               logger.log(`[Session ${sessionId}] Switch mode: ${mode}`);
+              if (isRestartingClaude || isSwitchingMode) {
+                logger.log(`[Session ${sessionId}] Switch mode deferred \u2014 restart/switch already in progress`);
+                return;
+              }
               currentPermissionMode = mode;
               if (claudeProcess && claudeProcess.exitCode === null) {
+                isSwitchingMode = true;
                 isKillingClaude = true;
-                await killAndWaitForExit2(claudeProcess);
-                isKillingClaude = false;
-                spawnClaude(void 0, { permissionMode: mode });
+                try {
+                  await killAndWaitForExit2(claudeProcess);
+                  isKillingClaude = false;
+                  if (trackedSession?.stopped) return;
+                  spawnClaude(void 0, { permissionMode: mode });
+                } finally {
+                  isKillingClaude = false;
+                  isSwitchingMode = false;
+                }
               }
             },
             onRestartClaude: restartClaudeHandler,
@@ -5817,11 +6134,15 @@ The automated loop has finished. Review the progress above and let me know if yo
             onMetadataUpdate: (newMeta) => {
               sessionMetadata = {
                 ...newMeta,
+                // 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)
+                ...sessionMetadata.claudeSessionId ? { claudeSessionId: sessionMetadata.claudeSessionId } : {},
                 ...sessionMetadata.summary && !newMeta.summary ? { summary: sessionMetadata.summary } : {},
                 ...sessionMetadata.sessionLink && !newMeta.sessionLink ? { sessionLink: sessionMetadata.sessionLink } : {}
               };
               const queue = newMeta.messageQueue;
-              if (queue && queue.length > 0 && !sessionWasProcessing) {
+              if (queue && queue.length > 0 && !sessionWasProcessing && !trackedSession.stopped) {
                 setTimeout(() => {
                   processMessageQueueRef?.();
                 }, 200);
@@ -5858,7 +6179,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             },
             onReadFile: async (path) => {
               const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
+              if (resolvedPath !== resolve(directory) && !resolvedPath.startsWith(resolve(directory) + "/")) {
                 throw new Error("Path outside working directory");
               }
               const buffer = await fs.readFile(resolvedPath);
@@ -5866,7 +6187,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             },
             onWriteFile: async (path, content) => {
               const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
+              if (resolvedPath !== resolve(directory) && !resolvedPath.startsWith(resolve(directory) + "/")) {
                 throw new Error("Path outside working directory");
               }
               await fs.mkdir(dirname(resolvedPath), { recursive: true });
@@ -5874,7 +6195,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             },
             onListDirectory: async (path) => {
               const resolvedDir = resolve(directory, path || ".");
-              if (!resolvedDir.startsWith(resolve(directory))) {
+              if (resolvedDir !== resolve(directory) && !resolvedDir.startsWith(resolve(directory) + "/")) {
                 throw new Error("Path outside working directory");
               }
               const entries = await fs.readdir(resolvedDir, { withFileTypes: true });
@@ -5913,6 +6234,9 @@ The automated loop has finished. Review the progress above and let me know if yo
                 }
               }
               const resolvedPath = resolve(directory, treePath);
+              if (resolvedPath !== resolve(directory) && !resolvedPath.startsWith(resolve(directory) + "/")) {
+                throw new Error("Path outside working directory");
+              }
               const tree = await buildTree(resolvedPath, basename(resolvedPath), 0);
               return { success: !!tree, tree };
             }
@@ -5929,13 +6253,18 @@ The automated loop has finished. Review the progress above and let me know if yo
           },
           sessionService,
           logger,
-          () => setTimeout(() => processMessageQueueRef?.(), 200)
+          () => {
+            if (!trackedSession?.stopped) setTimeout(() => processMessageQueueRef?.(), 200);
+          }
         );
         checkSvampConfig = svampConfig.check;
         cleanupSvampConfig = svampConfig.cleanup;
         const writeSvampConfigPatch = svampConfig.writeConfig;
         processMessageQueueRef = () => {
           if (sessionWasProcessing) return;
+          if (trackedSession?.stopped) return;
+          if (isKillingClaude) return;
+          if (isRestartingClaude || isSwitchingMode) return;
           const queue = sessionMetadata.messageQueue;
           if (queue && queue.length > 0) {
             const next = queue[0];
@@ -5964,22 +6293,33 @@ The automated loop has finished. Review the progress above and let me know if yo
                   isKillingClaude = true;
                   await killAndWaitForExit2(claudeProcess);
                   isKillingClaude = false;
+                  if (trackedSession?.stopped) return;
+                  if (isRestartingClaude || isSwitchingMode) return;
                   claudeResumeId = void 0;
                   spawnClaude(next.text, queueMeta);
                 } catch (err) {
                   logger.log(`[Session ${sessionId}] Error in fresh Ralph queue processing: ${err.message}`);
                   isKillingClaude = false;
+                  sessionWasProcessing = false;
                   signalProcessing(false);
                 }
               })();
-            } else if (!claudeProcess || claudeProcess.exitCode !== null) {
-              spawnClaude(next.text, queueMeta);
             } else {
-              const stdinMsg = JSON.stringify({
-                type: "user",
-                message: { role: "user", content: next.text }
-              });
-              claudeProcess.stdin?.write(stdinMsg + "\n");
+              try {
+                if (!claudeProcess || claudeProcess.exitCode !== null) {
+                  spawnClaude(next.text, queueMeta);
+                } else {
+                  const stdinMsg = JSON.stringify({
+                    type: "user",
+                    message: { role: "user", content: next.text }
+                  });
+                  claudeProcess.stdin?.write(stdinMsg + "\n");
+                }
+              } catch (err) {
+                logger.log(`[Session ${sessionId}] Error in processMessageQueue spawn: ${err.message}`);
+                sessionWasProcessing = false;
+                signalProcessing(false);
+              }
             }
           }
         };
@@ -5998,7 +6338,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             return claudeProcess || void 0;
           }
         };
-        pidToTrackedSession.set(process.pid + Math.floor(Math.random() * 1e5), trackedSession);
+        pidToTrackedSession.set(randomUUID$1(), trackedSession);
         sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
         sessionService.updateMetadata(sessionMetadata);
         logger.log(`Session ${sessionId} registered on Hypha, waiting for first message to spawn Claude`);
@@ -6009,6 +6349,10 @@ The automated loop has finished. Review the progress above and let me know if yo
         };
       } catch (err) {
         logger.error(`Failed to spawn session: ${err?.message || err}`, err?.stack);
+        if (stagedCredentials) {
+          stagedCredentials.cleanup().catch(() => {
+          });
+        }
         return {
           type: "error",
           errorMessage: `Failed to register session service: ${err?.message || String(err)}`
@@ -6076,6 +6420,7 @@ The automated loop has finished. Review the progress above and let me know if yo
           { controlledByUser: false },
           {
             onUserMessage: (content, meta) => {
+              if (acpStopped) return;
               logger.log(`[${agentName} Session ${sessionId}] User message received`);
               let text;
               let msgMeta = meta;
@@ -6096,8 +6441,35 @@ The automated loop has finished. Review the progress above and let me know if yo
               if (msgMeta?.permissionMode) {
                 currentPermissionMode = msgMeta.permissionMode;
               }
+              if (!acpBackendReady) {
+                logger.log(`[${agentName} Session ${sessionId}] Backend not ready \u2014 queuing message`);
+                const existingQueue = sessionMetadata.messageQueue || [];
+                sessionMetadata = {
+                  ...sessionMetadata,
+                  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 existingQueue = sessionMetadata.messageQueue || [];
+                sessionMetadata = {
+                  ...sessionMetadata,
+                  messageQueue: [...existingQueue, { id: randomUUID$1(), text, createdAt: Date.now() }]
+                };
+                sessionService.updateMetadata(sessionMetadata);
+                return;
+              }
+              sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
+              sessionService.updateMetadata(sessionMetadata);
               agentBackend.sendPrompt(sessionId, text).catch((err) => {
                 logger.error(`[${agentName} Session ${sessionId}] Error sending prompt:`, err);
+                if (!acpStopped) {
+                  sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
+                  sessionService.updateMetadata(sessionMetadata);
+                  sessionService.sendSessionEnd();
+                }
               });
             },
             onAbort: () => {
@@ -6151,18 +6523,27 @@ The automated loop has finished. Review the progress above and let me know if yo
             onMetadataUpdate: (newMeta) => {
               sessionMetadata = {
                 ...newMeta,
+                // Daemon drives lifecycleState — don't let frontend overwrite with stale value
+                lifecycleState: sessionMetadata.lifecycleState,
                 ...sessionMetadata.summary && !newMeta.summary ? { summary: sessionMetadata.summary } : {},
                 ...sessionMetadata.sessionLink && !newMeta.sessionLink ? { sessionLink: sessionMetadata.sessionLink } : {}
               };
+              if (acpStopped) return;
               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 };
+                sessionMetadata = { ...sessionMetadata, messageQueue: remaining.length > 0 ? remaining : void 0, lifecycleState: "running" };
                 sessionService.updateMetadata(sessionMetadata);
                 logger.log(`[Session ${sessionId}] Processing queued message from metadata update: "${next.text.slice(0, 50)}..."`);
+                sessionService.sendKeepAlive(true);
                 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);
+                    sessionService.sendSessionEnd();
+                  }
                 });
               }
             },
@@ -6196,7 +6577,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             },
             onReadFile: async (path) => {
               const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
+              if (resolvedPath !== resolve(directory) && !resolvedPath.startsWith(resolve(directory) + "/")) {
                 throw new Error("Path outside working directory");
               }
               const buffer = await fs.readFile(resolvedPath);
@@ -6204,7 +6585,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             },
             onWriteFile: async (path, content) => {
               const resolvedPath = resolve(directory, path);
-              if (!resolvedPath.startsWith(resolve(directory))) {
+              if (resolvedPath !== resolve(directory) && !resolvedPath.startsWith(resolve(directory) + "/")) {
                 throw new Error("Path outside working directory");
               }
               await fs.mkdir(dirname(resolvedPath), { recursive: true });
@@ -6212,7 +6593,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             },
             onListDirectory: async (path) => {
               const resolvedDir = resolve(directory, path || ".");
-              if (!resolvedDir.startsWith(resolve(directory))) {
+              if (resolvedDir !== resolve(directory) && !resolvedDir.startsWith(resolve(directory) + "/")) {
                 throw new Error("Path outside working directory");
               }
               const entries = await fs.readdir(resolvedDir, { withFileTypes: true });
@@ -6251,12 +6632,16 @@ The automated loop has finished. Review the progress above and let me know if yo
                 }
               }
               const resolvedPath = resolve(directory, treePath);
+              if (resolvedPath !== resolve(directory) && !resolvedPath.startsWith(resolve(directory) + "/")) {
+                throw new Error("Path outside working directory");
+              }
               const tree = await buildTree(resolvedPath, basename(resolvedPath), 0);
               return { success: !!tree, tree };
             }
           },
           { messagesDir: getSessionDir(directory, sessionId) }
         );
+        let insideOnTurnEnd = false;
         const svampConfigChecker = createSvampConfigChecker(
           directory,
           sessionId,
@@ -6268,6 +6653,8 @@ The automated loop has finished. Review the progress above and let me know if yo
           sessionService,
           logger,
           () => {
+            if (acpStopped) return;
+            if (insideOnTurnEnd) return;
             const queue = sessionMetadata.messageQueue;
             if (queue && queue.length > 0 && sessionMetadata.lifecycleState === "idle") {
               const next = queue[0];
@@ -6278,6 +6665,11 @@ The automated loop has finished. Review the progress above and let me know if yo
               sessionService.sendKeepAlive(true);
               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);
+                  sessionService.sendSessionEnd();
+                }
               });
             }
           }
@@ -6331,71 +6723,129 @@ The automated loop has finished. Review the progress above and let me know if yo
             isolationConfig: agentIsoConfig
           });
         }
+        let acpStopped = false;
+        let acpBackendReady = false;
         const onTurnEnd = (lastAssistantText) => {
-          checkSvampConfig?.();
-          const rlState = readRalphState(getRalphStateFilePath(directory, sessionId));
-          if (rlState) {
-            let promiseFulfilled = false;
-            if (rlState.completion_promise) {
-              const promiseMatch = lastAssistantText.match(/<promise>([\s\S]*?)<\/promise>/);
-              promiseFulfilled = !!(promiseMatch && promiseMatch[1].trim().replace(/\s+/g, " ") === rlState.completion_promise);
+          if (acpStopped) return;
+          insideOnTurnEnd = true;
+          try {
+            checkSvampConfig?.();
+            const rlState = readRalphState(getRalphStateFilePath(directory, sessionId));
+            if (rlState) {
+              let promiseFulfilled = false;
+              if (rlState.completion_promise) {
+                const promiseMatch = lastAssistantText.match(/<promise>([\s\S]*?)<\/promise>/);
+                promiseFulfilled = !!(promiseMatch && promiseMatch[1].trim().replace(/\s+/g, " ") === rlState.completion_promise);
+              }
+              const maxReached = rlState.max_iterations > 0 && rlState.iteration >= rlState.max_iterations;
+              if (promiseFulfilled || maxReached) {
+                removeRalphState(getRalphStateFilePath(directory, sessionId));
+                sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
+                sessionService.updateMetadata(sessionMetadata);
+                const reason = promiseFulfilled ? `Ralph loop completed at iteration ${rlState.iteration} \u2014 promise "${rlState.completion_promise}" fulfilled.` : `Ralph loop stopped \u2014 max iterations (${rlState.max_iterations}) reached.`;
+                logger.log(`[${agentName} Session ${sessionId}] ${reason}`);
+                sessionService.pushMessage({ type: "message", message: reason }, "event");
+              } else {
+                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);
+                  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);
+                      sessionService.sendSessionEnd();
+                    }
+                  });
+                  return;
+                }
+                const nextIteration = rlState.iteration + 1;
+                const iterationTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+                try {
+                  writeRalphState(getRalphStateFilePath(directory, sessionId), { ...rlState, iteration: nextIteration, last_iteration_at: iterationTimestamp });
+                } catch (writeErr) {
+                  logger.log(`[${agentName} Session ${sessionId}] Ralph: failed to persist state (iter ${nextIteration}): ${writeErr.message} \u2014 stopping loop`);
+                  sessionService.pushMessage({ type: "message", message: `Ralph loop error: failed to persist iteration state \u2014 loop stopped. (${writeErr.message})` }, "event");
+                  removeRalphState(getRalphStateFilePath(directory, sessionId));
+                  sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
+                  sessionService.updateMetadata(sessionMetadata);
+                  return;
+                }
+                const ralphLoop = {
+                  active: true,
+                  task: rlState.task,
+                  completionPromise: rlState.completion_promise ?? "none",
+                  maxIterations: rlState.max_iterations,
+                  currentIteration: nextIteration,
+                  startedAt: rlState.started_at,
+                  cooldownSeconds: rlState.cooldown_seconds,
+                  contextMode: rlState.context_mode || "fresh",
+                  lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
+                };
+                sessionMetadata = { ...sessionMetadata, ralphLoop, lifecycleState: "running" };
+                sessionService.updateMetadata(sessionMetadata);
+                logger.log(`[${agentName} Session ${sessionId}] Ralph loop iteration ${nextIteration}${rlState.max_iterations > 0 ? `/${rlState.max_iterations}` : ""}: spawning`);
+                const updatedState = { ...rlState, iteration: nextIteration, context_mode: "continue" };
+                const prompt = buildRalphPrompt(rlState.task, updatedState);
+                const cooldownMs = Math.max(200, rlState.cooldown_seconds * 1e3);
+                setTimeout(() => {
+                  if (acpStopped) return;
+                  const liveRlState = readRalphState(getRalphStateFilePath(directory, sessionId));
+                  if (!liveRlState) {
+                    sessionMetadata = { ...sessionMetadata, lifecycleState: "idle" };
+                    sessionService.updateMetadata(sessionMetadata);
+                    sessionService.sendKeepAlive(false);
+                    sessionService.sendSessionEnd();
+                    return;
+                  }
+                  sessionService.sendKeepAlive(true);
+                  sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
+                  sessionService.updateMetadata(sessionMetadata);
+                  sessionService.pushMessage({ type: "message", message: buildIterationStatus(nextIteration, rlState.max_iterations, rlState.completion_promise) }, "event");
+                  sessionService.pushMessage(rlState.task, "user");
+                  agentBackend.sendPrompt(sessionId, prompt).catch((err) => {
+                    logger.error(`[${agentName} Session ${sessionId}] Error in Ralph loop: ${err.message}`);
+                    if (!acpStopped) {
+                      removeRalphState(getRalphStateFilePath(directory, sessionId));
+                      sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
+                      sessionService.updateMetadata(sessionMetadata);
+                      sessionService.sendSessionEnd();
+                      sessionService.pushMessage({ type: "message", message: `Ralph loop error: agent failed to start turn \u2014 loop stopped. (${err.message})` }, "event");
+                    }
+                  });
+                }, cooldownMs);
+                return;
+              }
             }
-            const maxReached = rlState.max_iterations > 0 && rlState.iteration >= rlState.max_iterations;
-            if (promiseFulfilled || maxReached) {
-              removeRalphState(getRalphStateFilePath(directory, sessionId));
-              sessionMetadata = { ...sessionMetadata, ralphLoop: { active: false }, lifecycleState: "idle" };
-              sessionService.updateMetadata(sessionMetadata);
-              const reason = promiseFulfilled ? `Ralph loop completed at iteration ${rlState.iteration} \u2014 promise "${rlState.completion_promise}" fulfilled.` : `Ralph loop stopped \u2014 max iterations (${rlState.max_iterations}) reached.`;
-              logger.log(`[${agentName} Session ${sessionId}] ${reason}`);
-              sessionService.pushMessage({ type: "message", message: reason }, "event");
-            } else {
-              const nextIteration = rlState.iteration + 1;
-              const iterationTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-              writeRalphState(getRalphStateFilePath(directory, sessionId), { ...rlState, iteration: nextIteration, last_iteration_at: iterationTimestamp });
-              const ralphLoop = {
-                active: true,
-                task: rlState.task,
-                completionPromise: rlState.completion_promise ?? "none",
-                maxIterations: rlState.max_iterations,
-                currentIteration: nextIteration,
-                startedAt: rlState.started_at,
-                cooldownSeconds: rlState.cooldown_seconds,
-                contextMode: rlState.context_mode || "fresh",
-                lastIterationStartedAt: (/* @__PURE__ */ new Date()).toISOString()
-              };
-              sessionMetadata = { ...sessionMetadata, ralphLoop };
+            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);
-              logger.log(`[${agentName} Session ${sessionId}] Ralph loop iteration ${nextIteration}${rlState.max_iterations > 0 ? `/${rlState.max_iterations}` : ""}: spawning`);
-              const updatedState = { ...rlState, iteration: nextIteration, context_mode: "continue" };
-              const prompt = buildRalphPrompt(rlState.task, updatedState);
-              const cooldownMs = Math.max(200, rlState.cooldown_seconds * 1e3);
-              setTimeout(() => {
-                sessionService.sendKeepAlive(true);
-                sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
-                sessionService.updateMetadata(sessionMetadata);
-                sessionService.pushMessage({ type: "message", message: buildIterationStatus(nextIteration, rlState.max_iterations, rlState.completion_promise) }, "event");
-                sessionService.pushMessage(rlState.task, "user");
-                agentBackend.sendPrompt(sessionId, prompt).catch((err) => {
-                  logger.error(`[${agentName} Session ${sessionId}] Error in Ralph loop: ${err.message}`);
-                });
-              }, cooldownMs);
-              return;
+              sessionService.sendKeepAlive(true);
+              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);
+                  sessionService.sendSessionEnd();
+                }
+              });
             }
-          }
-          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);
-            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}`);
-            });
+          } finally {
+            insideOnTurnEnd = false;
           }
         };
-        bridgeAcpToSession(
+        const cleanupBridge = bridgeAcpToSession(
           agentBackend,
           sessionService,
           () => sessionMetadata,
@@ -6417,11 +6867,19 @@ The automated loop has finished. Review the progress above and let me know if yo
           resumeSessionId,
           get childProcess() {
             return agentBackend.getProcess?.() || void 0;
+          },
+          onStop: () => {
+            acpStopped = true;
+            cleanupBridge();
+            permissionHandler.rejectAll("session stopped");
+            agentBackend.dispose().catch(() => {
+            });
           }
         };
-        pidToTrackedSession.set(process.pid + Math.floor(Math.random() * 1e5), trackedSession);
+        pidToTrackedSession.set(randomUUID$1(), trackedSession);
         logger.log(`[Agent Session ${sessionId}] Starting ${agentName} backend...`);
         agentBackend.startSession().then(() => {
+          acpBackendReady = true;
           logger.log(`[Agent Session ${sessionId}] ${agentName} backend started, waiting for first message`);
         }).catch((err) => {
           logger.error(`[Agent Session ${sessionId}] Failed to start ${agentName}:`, err);
@@ -6430,6 +6888,7 @@ The automated loop has finished. Review the progress above and let me know if yo
             "event"
           );
           sessionService.sendSessionEnd();
+          stopSession(sessionId);
         });
         return {
           type: "success",
@@ -6449,6 +6908,7 @@ The automated loop has finished. Review the progress above and let me know if yo
       for (const [pid, session] of pidToTrackedSession) {
         if (session.svampSessionId === sessionId) {
           session.stopped = true;
+          session.onStop?.();
           session.hyphaService?.disconnect().catch(() => {
           });
           if (session.childProcess) {
@@ -6460,12 +6920,14 @@ The automated loop has finished. Review the progress above and let me know if yo
           session.cleanupCredentials?.().catch(() => {
           });
           session.cleanupSvampConfig?.();
+          artifactSync.cancelSync(sessionId);
           pidToTrackedSession.delete(pid);
           deletePersistedSession(sessionId);
           logger.log(`Session ${sessionId} stopped`);
           return true;
         }
       }
+      artifactSync.cancelSync(sessionId);
       deletePersistedSession(sessionId);
       logger.log(`Session ${sessionId} not found in memory, cleaned up persisted state`);
       return false;
@@ -6602,14 +7064,20 @@ The automated loop has finished. Review the progress above and let me know if yo
       for (const sessionId of sessionsToAutoContinue) {
         setTimeout(async () => {
           try {
-            const svc = await server.getService(`svamp-session-${sessionId}`);
-            await svc.sendMessage(
-              JSON.stringify({
-                role: "user",
-                content: { type: "text", text: "The session was interrupted. Please continue." },
-                meta: { sentFrom: "svamp-daemon-auto-continue" }
-              })
-            );
+            const svc = await Promise.race([
+              server.getService(`svamp-session-${sessionId}`),
+              new Promise((_, reject) => setTimeout(() => reject(new Error("getService timeout")), 1e4))
+            ]);
+            await Promise.race([
+              svc.sendMessage(
+                JSON.stringify({
+                  role: "user",
+                  content: { type: "text", text: 'The svamp daemon was restarted, which interrupted this session. Please continue where you left off. IMPORTANT: Do not run any command that would stop or restart the svamp daemon (e.g. "svamp daemon stop") \u2014 that would interrupt the session again.' },
+                  meta: { sentFrom: "svamp-daemon-auto-continue" }
+                })
+              ),
+              new Promise((_, reject) => setTimeout(() => reject(new Error("sendMessage timeout")), 3e4))
+            ]);
             logger.log(`Auto-continued session ${sessionId}`);
           } catch (err) {
             logger.log(`Failed to auto-continue session ${sessionId}: ${err.message}`);
@@ -6623,7 +7091,10 @@ The automated loop has finished. Review the progress above and let me know if yo
       logger.log(`Resuming Ralph loop for ${sessionsToRalphResume.length} session(s)...`);
       for (const { sessionId, directory: sessDir } of sessionsToRalphResume) {
         try {
-          const svc = await server.getService(`svamp-session-${sessionId}`);
+          const svc = await Promise.race([
+            server.getService(`svamp-session-${sessionId}`),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("getService timeout")), 1e4))
+          ]);
           const rlState = readRalphState(getRalphStateFilePath(sessDir, sessionId));
           if (!rlState) continue;
           const initDelayMs = 2e3;
@@ -6644,17 +7115,20 @@ The automated loop has finished. Review the progress above and let me know if yo
               const progressRelPath = `.svamp/${sessionId}/ralph-progress.md`;
               const prompt = buildRalphPrompt(currentState.task, currentState);
               const ralphSysPrompt = buildRalphSystemPrompt(currentState, progressRelPath);
-              await svc.sendMessage(
-                JSON.stringify({
-                  role: "user",
-                  content: { type: "text", text: prompt },
-                  meta: {
-                    sentFrom: "svamp-daemon-ralph-resume",
-                    appendSystemPrompt: ralphSysPrompt,
-                    ...isFreshMode ? { ralphFreshContext: true } : {}
-                  }
-                })
-              );
+              await Promise.race([
+                svc.sendMessage(
+                  JSON.stringify({
+                    role: "user",
+                    content: { type: "text", text: prompt },
+                    meta: {
+                      sentFrom: "svamp-daemon-ralph-resume",
+                      appendSystemPrompt: ralphSysPrompt,
+                      ...isFreshMode ? { ralphFreshContext: true } : {}
+                    }
+                  })
+                ),
+                new Promise((_, reject) => setTimeout(() => reject(new Error("sendMessage timeout")), 3e4))
+              ]);
               logger.log(`Resumed Ralph loop for session ${sessionId} at iteration ${currentState.iteration} (${isFreshMode ? "fresh" : "continue"})`);
             } catch (err) {
               logger.log(`Failed to resume Ralph loop for session ${sessionId}: ${err.message}`);
@@ -6740,9 +7214,16 @@ The automated loop has finished. Review the progress above and let me know if yo
               process.kill(child.pid, 0);
             } catch {
               logger.log(`Removing stale session (child PID ${child.pid} dead): ${session.svampSessionId}`);
+              session.stopped = true;
+              session.onStop?.();
               session.hyphaService?.disconnect().catch(() => {
               });
+              session.cleanupCredentials?.().catch(() => {
+              });
+              session.cleanupSvampConfig?.();
+              if (session.svampSessionId) artifactSync.cancelSync(session.svampSessionId);
               pidToTrackedSession.delete(key);
+              if (session.svampSessionId) deletePersistedSession(session.svampSessionId);
             }
           }
         }
@@ -6810,6 +7291,10 @@ The automated loop has finished. Review the progress above and let me know if yo
       clearInterval(heartbeatInterval);
       if (proxyTokenRefreshInterval) clearInterval(proxyTokenRefreshInterval);
       if (unhandledRejectionResetTimer) clearTimeout(unhandledRejectionResetTimer);
+      for (const [, session] of pidToTrackedSession) {
+        session.stopped = true;
+        session.onStop?.();
+      }
       machineService.updateDaemonState({
         ...initialDaemonState,
         status: "shutting-down",
@@ -6817,7 +7302,7 @@ The automated loop has finished. Review the progress above and let me know if yo
         shutdownSource: source
       });
       await new Promise((r) => setTimeout(r, 200));
-      for (const [pid, session] of pidToTrackedSession) {
+      for (const [, session] of pidToTrackedSession) {
         session.hyphaService?.disconnect().catch(() => {
         });
         if (session.childProcess) {
@@ -6834,14 +7319,21 @@ The automated loop has finished. Review the progress above and let me know if yo
       if (shouldMarkStopped) {
         try {
           const index = loadSessionIndex();
+          let markedCount = 0;
           for (const [sessionId, entry] of Object.entries(index)) {
-            const filePath = getSessionFilePath(entry.directory, sessionId);
-            if (existsSync$1(filePath)) {
-              const data = JSON.parse(readFileSync$1(filePath, "utf-8"));
-              writeFileSync(filePath, JSON.stringify({ ...data, stopped: true }, null, 2), "utf-8");
+            try {
+              const filePath = getSessionFilePath(entry.directory, sessionId);
+              if (existsSync$1(filePath)) {
+                const data = JSON.parse(readFileSync$1(filePath, "utf-8"));
+                const tmpPath = filePath + ".tmp";
+                writeFileSync(tmpPath, JSON.stringify({ ...data, stopped: true }, null, 2), "utf-8");
+                renameSync(tmpPath, filePath);
+                markedCount++;
+              }
+            } catch {
             }
           }
-          logger.log("Marked all sessions as stopped (--cleanup mode)");
+          logger.log(`Marked ${markedCount} session(s) as stopped (--cleanup mode)`);
         } catch {
         }
       } else {