svamp-cli 0.1.69 → 0.1.71

package/dist/{run-DxmtlxnM.mjs → run-DGKMT1Af.mjs}

@@ -1,5 +1,5 @@
 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, rename, unlink } from 'fs/promises';
+import fs, { mkdir as mkdir$1, readdir, readFile, writeFile as writeFile$1, rename, unlink } from 'fs/promises';
 import { readFileSync as readFileSync$1, mkdirSync, writeFileSync, renameSync, existsSync as existsSync$1, copyFileSync, unlinkSync, watch, rmdirSync } from 'fs';
 import path, { join, dirname, resolve, basename } from 'path';
 import { fileURLToPath } from 'url';
@@ -15,7 +15,7 @@ import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { ElicitRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { z } from 'zod';
-import { mkdir, rm, chmod, access, mkdtemp, copyFile } from 'node:fs/promises';
+import { mkdir, rm, chmod, access, mkdtemp, copyFile, writeFile } from 'node:fs/promises';
 import { promisify } from 'node:util';
 
 let connectToServerFn = null;
@@ -45,6 +45,11 @@ async function connectToHypha(config) {
       "Timeout connecting to Hypha server (30s). A previous daemon may still be connected. Retrying..."
     )), 3e4))
   ]);
+  if (!server.on && server.rpc) {
+    server.on = server.rpc.on.bind(server.rpc);
+    server.off = server.rpc.off.bind(server.rpc);
+    server.emit = server.rpc.emit.bind(server.rpc);
+  }
   return server;
 }
 function parseWorkspaceFromToken(token) {
@@ -378,6 +383,72 @@ async function registerMachineService(server, machineId, metadata, daemonState,
         authorizeRequest(context, currentMetadata.sharing, "view");
         return handlers.getTrackedSessions();
       },
+      /**
+       * Get summary info for all sessions (metadata, agent state, activity).
+       * Replaces the need to discover and query N individual session services.
+       */
+      getSessions: async (context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        const sessionIds = handlers.getSessionIds?.() || [];
+        const sessions = [];
+        for (const sid of sessionIds) {
+          const rpc = handlers.getSessionRPCHandlers?.(sid);
+          if (!rpc) continue;
+          try {
+            const [metaResult, stateResult, activity] = await Promise.all([
+              rpc.getMetadata(context),
+              rpc.getAgentState(context),
+              rpc.getActivityState(context).catch(() => ({
+                active: false,
+                thinking: false,
+                time: Date.now()
+              }))
+            ]);
+            sessions.push({
+              id: sid,
+              metadata: metaResult.metadata,
+              metadataVersion: metaResult.version,
+              agentState: stateResult.agentState,
+              agentStateVersion: stateResult.version,
+              active: activity.active ?? false,
+              thinking: activity.thinking ?? false,
+              activeAt: activity.time || Date.now()
+            });
+          } catch {
+          }
+        }
+        return sessions;
+      },
+      /**
+       * Dispatch an RPC call to a specific session's handler.
+       * This consolidates all session RPCs through the machine service,
+       * eliminating the need for per-session Hypha service registration.
+       */
+      sessionRPC: async (sessionId, method, args, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        const rpc = handlers.getSessionRPCHandlers?.(sessionId);
+        if (!rpc) {
+          throw new Error(`Session ${sessionId} not found on this machine`);
+        }
+        const handler = rpc[method];
+        if (typeof handler !== "function") {
+          throw new Error(`Unknown session method: ${method}`);
+        }
+        const argArray = Array.isArray(args) ? args : args !== void 0 ? [args] : [];
+        return await handler(...argArray, context);
+      },
+      /**
+       * Register a listener for a specific session's real-time updates.
+       * Delegates to the session store's registerListener.
+       */
+      registerSessionListener: async (sessionId, callback, context) => {
+        authorizeRequest(context, currentMetadata.sharing, "view");
+        const rpc = handlers.getSessionRPCHandlers?.(sessionId);
+        if (!rpc) {
+          throw new Error(`Session ${sessionId} not found on this machine`);
+        }
+        return await rpc.registerListener(callback, context);
+      },
       // Spawn a new session
       spawnSession: async (options, context) => {
         authorizeRequest(context, currentMetadata.sharing, "interact");
@@ -771,6 +842,7 @@ async function registerMachineService(server, machineId, metadata, daemonState,
   console.log(`[HYPHA MACHINE] Machine service registered: ${serviceInfo.id}`);
   return {
     serviceInfo,
+    notifySessionEvent: notifyListeners,
     updateMetadata: (newMetadata) => {
       currentMetadata = newMetadata;
       metadataVersion++;
@@ -827,7 +899,7 @@ function appendMessage(messagesDir, sessionId, msg) {
     console.error(`[HYPHA SESSION ${sessionId}] Failed to persist message: ${err?.message ?? err}`);
   }
 }
-async function registerSessionService(server, sessionId, initialMetadata, initialAgentState, callbacks, options) {
+function createSessionStore(server, sessionId, initialMetadata, initialAgentState, callbacks, options) {
   const messages = options?.messagesDir ? loadMessages(options.messagesDir) : [];
   let nextSeq = messages.length > 0 ? messages[messages.length - 1].seq + 1 : 1;
   let metadata = { ...initialMetadata };
@@ -854,6 +926,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
     }
   };
   const notifyListeners = (update) => {
+    options?.onSessionEvent?.(update);
     const snapshot = [...listeners];
     for (let i = snapshot.length - 1; i >= 0; i--) {
       const listener = snapshot[i];
@@ -880,7 +953,7 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
       }
       wrappedContent = { role: "agent", content: { type: "output", data } };
     } else if (role === "event") {
-      wrappedContent = { role: "agent", content: { type: "event", data: content } };
+      wrappedContent = { role: "agent", content: { type: "event", id: randomUUID(), data: content } };
     } else if (role === "session") {
       wrappedContent = { role: "session", content: { type: "session", data: content } };
     } else {
@@ -907,356 +980,348 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
     });
     return msg;
   };
-  const serviceInfo = await server.registerService(
-    {
-      id: `svamp-session-${sessionId}`,
-      name: `Svamp Session ${sessionId.slice(0, 8)}`,
-      type: "svamp-session",
-      config: { visibility: "unlisted", require_context: true },
-      // ── Messages ──
-      getMessages: async (afterSeq, limit, context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        const after = afterSeq ?? 0;
-        const lim = Math.min(limit ?? 100, 500);
-        const filtered = messages.filter((m) => m.seq > after);
-        const page = filtered.slice(0, lim);
-        return {
-          messages: page,
-          hasMore: filtered.length > lim
-        };
-      },
-      sendMessage: async (content, localId, meta, context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
-        if (localId) {
-          const existing = messages.find((m) => m.localId === localId);
-          if (existing) {
-            return { id: existing.id, seq: existing.seq, localId: existing.localId };
-          }
-        }
-        let parsed = content;
-        if (typeof parsed === "string") {
-          try {
-            parsed = JSON.parse(parsed);
-          } catch {
-          }
-        }
-        if (parsed && typeof parsed.content === "string" && !parsed.role) {
-          try {
-            const inner = JSON.parse(parsed.content);
-            if (inner && typeof inner === "object") parsed = inner;
-          } catch {
-          }
+  const rpcHandlers = {
+    // ── Messages ──
+    getMessages: async (afterSeq, limit, context) => {
+      authorizeRequest(context, metadata.sharing, "view");
+      const after = afterSeq ?? 0;
+      const lim = Math.min(limit ?? 100, 500);
+      const filtered = messages.filter((m) => m.seq > after);
+      const page = filtered.slice(0, lim);
+      return {
+        messages: page,
+        hasMore: filtered.length > lim
+      };
+    },
+    sendMessage: async (content, localId, meta, context) => {
+      authorizeRequest(context, metadata.sharing, "interact");
+      if (localId) {
+        const existing = messages.find((m) => m.localId === localId);
+        if (existing) {
+          return { id: existing.id, seq: existing.seq, localId: existing.localId };
         }
-        const wrappedContent = parsed && parsed.role === "user" ? { role: "user", content: parsed.content } : { role: "user", content: { type: "text", text: typeof parsed === "string" ? parsed : JSON.stringify(parsed) } };
-        const msg = {
-          id: randomUUID(),
-          seq: nextSeq++,
-          content: wrappedContent,
-          localId: localId || randomUUID(),
-          createdAt: Date.now(),
-          updatedAt: Date.now()
-        };
-        messages.push(msg);
-        if (messages.length > 1e3) messages.splice(0, messages.length - 1e3);
-        if (options?.messagesDir) {
-          appendMessage(options.messagesDir, sessionId, msg);
+      }
+      let parsed = content;
+      if (typeof parsed === "string") {
+        try {
+          parsed = JSON.parse(parsed);
+        } catch {
         }
-        notifyListeners({
-          type: "new-message",
-          sessionId,
-          message: msg
-        });
-        callbacks.onUserMessage(content, meta);
-        return { id: msg.id, seq: msg.seq, localId: msg.localId };
-      },
-      // ── Metadata ──
-      getMetadata: async (context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        return {
-          metadata,
-          version: metadataVersion
-        };
-      },
-      updateMetadata: async (newMetadata, expectedVersion, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (expectedVersion !== void 0 && expectedVersion !== metadataVersion) {
-          return {
-            result: "version-mismatch",
-            version: metadataVersion,
-            metadata
-          };
+      }
+      if (parsed && typeof parsed.content === "string" && !parsed.role) {
+        try {
+          const inner = JSON.parse(parsed.content);
+          if (inner && typeof inner === "object") parsed = inner;
+        } catch {
         }
-        metadata = newMetadata;
-        metadataVersion++;
-        notifyListeners({
-          type: "update-session",
-          sessionId,
-          metadata: { value: metadata, version: metadataVersion }
-        });
-        callbacks.onMetadataUpdate?.(metadata);
+      }
+      const wrappedContent = parsed && parsed.role === "user" ? { role: "user", content: parsed.content } : { role: "user", content: { type: "text", text: typeof parsed === "string" ? parsed : JSON.stringify(parsed) } };
+      const msg = {
+        id: randomUUID(),
+        seq: nextSeq++,
+        content: wrappedContent,
+        localId: localId || randomUUID(),
+        createdAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      messages.push(msg);
+      if (messages.length > 1e3) messages.splice(0, messages.length - 1e3);
+      if (options?.messagesDir) {
+        appendMessage(options.messagesDir, sessionId, msg);
+      }
+      notifyListeners({
+        type: "new-message",
+        sessionId,
+        message: msg
+      });
+      callbacks.onUserMessage(content, meta);
+      return { id: msg.id, seq: msg.seq, localId: msg.localId };
+    },
+    // ── Metadata ──
+    getMetadata: async (context) => {
+      authorizeRequest(context, metadata.sharing, "view");
+      return {
+        metadata,
+        version: metadataVersion
+      };
+    },
+    updateMetadata: async (newMetadata, expectedVersion, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (expectedVersion !== void 0 && expectedVersion !== metadataVersion) {
         return {
-          result: "success",
+          result: "version-mismatch",
           version: metadataVersion,
           metadata
         };
-      },
-      /**
-       * Patch the session config file (.svamp/{sessionId}/config.json).
-       * Used by the frontend to set title, session_link, ralph_loop, etc.
-       * Null values remove keys from the config.
-       */
-      updateConfig: async (patch, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        callbacks.onUpdateConfig?.(patch);
-        return { success: true };
-      },
-      // ── Agent State ──
-      getAgentState: async (context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        return {
-          agentState,
-          version: agentStateVersion
-        };
-      },
-      updateAgentState: async (newState, expectedVersion, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (expectedVersion !== void 0 && expectedVersion !== agentStateVersion) {
-          return {
-            result: "version-mismatch",
-            version: agentStateVersion,
-            agentState
-          };
-        }
-        agentState = newState;
-        agentStateVersion++;
-        notifyListeners({
-          type: "update-session",
-          sessionId,
-          agentState: { value: agentState, version: agentStateVersion }
-        });
+      }
+      metadata = newMetadata;
+      metadataVersion++;
+      notifyListeners({
+        type: "update-session",
+        sessionId,
+        metadata: { value: metadata, version: metadataVersion }
+      });
+      callbacks.onMetadataUpdate?.(metadata);
+      return {
+        result: "success",
+        version: metadataVersion,
+        metadata
+      };
+    },
+    /**
+     * Patch the session config file (.svamp/{sessionId}/config.json).
+     * Used by the frontend to set title, session_link, ralph_loop, etc.
+     * Null values remove keys from the config.
+     */
+    updateConfig: async (patch, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      callbacks.onUpdateConfig?.(patch);
+      return { success: true };
+    },
+    // ── Agent State ──
+    getAgentState: async (context) => {
+      authorizeRequest(context, metadata.sharing, "view");
+      return {
+        agentState,
+        version: agentStateVersion
+      };
+    },
+    updateAgentState: async (newState, expectedVersion, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (expectedVersion !== void 0 && expectedVersion !== agentStateVersion) {
         return {
-          result: "success",
+          result: "version-mismatch",
           version: agentStateVersion,
           agentState
         };
-      },
-      // ── Session Control RPCs ──
-      abort: async (context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
-        callbacks.onAbort();
-        return { success: true };
-      },
-      permissionResponse: async (params, context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
-        callbacks.onPermissionResponse(params);
-        return { success: true };
-      },
-      switchMode: async (mode, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        callbacks.onSwitchMode(mode);
-        return { success: true };
-      },
-      restartClaude: async (context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        return await callbacks.onRestartClaude();
-      },
-      killSession: async (context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        callbacks.onKillSession();
-        return { success: true };
-      },
-      // ── Activity ──
-      keepAlive: async (thinking, mode, context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
-        lastActivity = { active: true, thinking: thinking || false, mode: mode || "remote", time: Date.now() };
-        notifyListeners({
-          type: "activity",
-          sessionId,
-          ...lastActivity
-        });
-      },
-      sessionEnd: async (context) => {
-        authorizeRequest(context, metadata.sharing, "interact");
-        lastActivity = { active: false, thinking: false, mode: "remote", time: Date.now() };
-        notifyListeners({
-          type: "activity",
-          sessionId,
-          ...lastActivity
-        });
-      },
-      // ── Activity State Query ──
-      getActivityState: async (context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        const pendingPermissions = agentState?.requests ? Object.entries(agentState.requests).filter(([, req]) => req.status === "pending" || !req.status).map(([id, req]) => ({
-          id,
-          tool: req.tool,
-          arguments: req.arguments,
-          createdAt: req.createdAt
-        })) : [];
-        return { ...lastActivity, sessionId, pendingPermissions };
-      },
-      // ── File Operations (optional, admin-only) ──
-      readFile: async (path, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onReadFile) throw new Error("readFile not supported");
-        return await callbacks.onReadFile(path);
-      },
-      writeFile: async (path, content, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onWriteFile) throw new Error("writeFile not supported");
-        await callbacks.onWriteFile(path, content);
-        return { success: true };
-      },
-      listDirectory: async (path, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onListDirectory) throw new Error("listDirectory not supported");
-        return await callbacks.onListDirectory(path);
-      },
-      bash: async (command, cwd, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onBash) throw new Error("bash not supported");
-        return await callbacks.onBash(command, cwd);
-      },
-      ripgrep: async (args, cwd, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onRipgrep) throw new Error("ripgrep not supported");
+      }
+      agentState = newState;
+      agentStateVersion++;
+      notifyListeners({
+        type: "update-session",
+        sessionId,
+        agentState: { value: agentState, version: agentStateVersion }
+      });
+      return {
+        result: "success",
+        version: agentStateVersion,
+        agentState
+      };
+    },
+    // ── Session Control RPCs ──
+    abort: async (context) => {
+      authorizeRequest(context, metadata.sharing, "interact");
+      callbacks.onAbort();
+      return { success: true };
+    },
+    permissionResponse: async (params, context) => {
+      authorizeRequest(context, metadata.sharing, "interact");
+      callbacks.onPermissionResponse(params);
+      return { success: true };
+    },
+    switchMode: async (mode, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      callbacks.onSwitchMode(mode);
+      return { success: true };
+    },
+    restartClaude: async (context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      return await callbacks.onRestartClaude();
+    },
+    killSession: async (context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      callbacks.onKillSession();
+      return { success: true };
+    },
+    // ── Activity ──
+    keepAlive: async (thinking, mode, context) => {
+      authorizeRequest(context, metadata.sharing, "interact");
+      lastActivity = { active: true, thinking: thinking || false, mode: mode || "remote", time: Date.now() };
+      notifyListeners({
+        type: "activity",
+        sessionId,
+        ...lastActivity
+      });
+    },
+    sessionEnd: async (context) => {
+      authorizeRequest(context, metadata.sharing, "interact");
+      lastActivity = { active: false, thinking: false, mode: "remote", time: Date.now() };
+      notifyListeners({
+        type: "activity",
+        sessionId,
+        ...lastActivity
+      });
+    },
+    // ── Activity State Query ──
+    getActivityState: async (context) => {
+      authorizeRequest(context, metadata.sharing, "view");
+      const pendingPermissions = agentState?.requests ? Object.entries(agentState.requests).filter(([, req]) => req.status === "pending" || !req.status).map(([id, req]) => ({
+        id,
+        tool: req.tool,
+        arguments: req.arguments,
+        createdAt: req.createdAt
+      })) : [];
+      return { ...lastActivity, sessionId, pendingPermissions };
+    },
+    // ── File Operations (optional, admin-only) ──
+    readFile: async (path, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!callbacks.onReadFile) throw new Error("readFile not supported");
+      return await callbacks.onReadFile(path);
+    },
+    writeFile: async (path, content, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!callbacks.onWriteFile) throw new Error("writeFile not supported");
+      await callbacks.onWriteFile(path, content);
+      return { success: true };
+    },
+    listDirectory: async (path, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!callbacks.onListDirectory) throw new Error("listDirectory not supported");
+      return await callbacks.onListDirectory(path);
+    },
+    bash: async (command, cwd, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!callbacks.onBash) throw new Error("bash not supported");
+      return await callbacks.onBash(command, cwd);
+    },
+    ripgrep: async (args, cwd, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!callbacks.onRipgrep) throw new Error("ripgrep not supported");
+      try {
+        const stdout = await callbacks.onRipgrep(args, cwd);
+        return { success: true, stdout, stderr: "", exitCode: 0 };
+      } catch (err) {
+        return { success: false, stdout: "", stderr: err.message || "", exitCode: 1, error: err.message };
+      }
+    },
+    getDirectoryTree: async (path, maxDepth, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!callbacks.onGetDirectoryTree) throw new Error("getDirectoryTree not supported");
+      return await callbacks.onGetDirectoryTree(path, maxDepth ?? 3);
+    },
+    // ── Sharing Management ──
+    getSharing: async (context) => {
+      authorizeRequest(context, metadata.sharing, "view");
+      return { sharing: metadata.sharing || null };
+    },
+    /** 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 };
+    },
+    updateSharing: async (newSharing, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (metadata.sharing && context?.user?.email && metadata.sharing.owner && context.user.email.toLowerCase() !== metadata.sharing.owner.toLowerCase()) {
+        throw new Error("Only the session owner can update sharing settings");
+      }
+      if (newSharing.enabled && !newSharing.owner && context?.user?.email) {
+        newSharing = { ...newSharing, owner: context.user.email };
+      }
+      metadata = { ...metadata, sharing: newSharing };
+      metadataVersion++;
+      notifyListeners({
+        type: "update-session",
+        sessionId,
+        metadata: { value: metadata, version: metadataVersion }
+      });
+      callbacks.onSharingUpdate?.(newSharing);
+      return { success: true, sharing: newSharing };
+    },
+    /** Update security context and restart the agent process with new rules */
+    updateSecurityContext: async (newSecurityContext, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (metadata.sharing && context?.user?.email && metadata.sharing.owner && context.user.email.toLowerCase() !== metadata.sharing.owner.toLowerCase()) {
+        throw new Error("Only the session owner can update security context");
+      }
+      if (!callbacks.onUpdateSecurityContext) {
+        throw new Error("Security context updates are not supported for this session");
+      }
+      metadata = { ...metadata, securityContext: newSecurityContext };
+      metadataVersion++;
+      notifyListeners({
+        type: "update-session",
+        sessionId,
+        metadata: { value: metadata, version: metadataVersion }
+      });
+      return await callbacks.onUpdateSecurityContext(newSecurityContext);
+    },
+    /** Apply a new system prompt and restart the agent process */
+    applySystemPrompt: async (prompt, context) => {
+      authorizeRequest(context, metadata.sharing, "admin");
+      if (!callbacks.onApplySystemPrompt) {
+        throw new Error("System prompt updates are not supported for this session");
+      }
+      return await callbacks.onApplySystemPrompt(prompt);
+    },
+    // ── Listener Registration ──
+    registerListener: async (callback, context) => {
+      authorizeRequest(context, metadata.sharing, "view");
+      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 stdout = await callbacks.onRipgrep(args, cwd);
-          return { success: true, stdout, stderr: "", exitCode: 0 };
+          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) {
-          return { success: false, stdout: "", stderr: err.message || "", exitCode: 1, error: err.message };
+          console.error(`[HYPHA SESSION ${sessionId}] Replay listener error, removing:`, err?.message ?? err);
+          removeListener(callback, "replay error");
+          return { success: false, error: "Listener removed during replay" };
         }
-      },
-      getDirectoryTree: async (path, maxDepth, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onGetDirectoryTree) throw new Error("getDirectoryTree not supported");
-        return await callbacks.onGetDirectoryTree(path, maxDepth ?? 3);
-      },
-      // ── Sharing Management ──
-      getSharing: async (context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        return { sharing: metadata.sharing || null };
-      },
-      /** 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 };
-      },
-      updateSharing: async (newSharing, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (metadata.sharing && context?.user?.email && metadata.sharing.owner && context.user.email.toLowerCase() !== metadata.sharing.owner.toLowerCase()) {
-          throw new Error("Only the session owner can update sharing settings");
-        }
-        if (newSharing.enabled && !newSharing.owner && context?.user?.email) {
-          newSharing = { ...newSharing, owner: context.user.email };
-        }
-        metadata = { ...metadata, sharing: newSharing };
-        metadataVersion++;
-        notifyListeners({
+      }
+      if (listeners.indexOf(callback) < 0) {
+        return { success: false, error: "Listener was removed during replay" };
+      }
+      try {
+        const result = callback.onUpdate({
           type: "update-session",
           sessionId,
-          metadata: { value: metadata, version: metadataVersion }
+          metadata: { value: metadata, version: metadataVersion },
+          agentState: { value: agentState, version: agentStateVersion }
         });
-        callbacks.onSharingUpdate?.(newSharing);
-        return { success: true, sharing: newSharing };
-      },
-      /** Update security context and restart the agent process with new rules */
-      updateSecurityContext: async (newSecurityContext, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (metadata.sharing && context?.user?.email && metadata.sharing.owner && context.user.email.toLowerCase() !== metadata.sharing.owner.toLowerCase()) {
-          throw new Error("Only the session owner can update security context");
-        }
-        if (!callbacks.onUpdateSecurityContext) {
-          throw new Error("Security context updates are not supported for this session");
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
+          });
         }
-        metadata = { ...metadata, securityContext: newSecurityContext };
-        metadataVersion++;
-        notifyListeners({
-          type: "update-session",
+      } catch {
+      }
+      try {
+        const result = callback.onUpdate({
+          type: "activity",
           sessionId,
-          metadata: { value: metadata, version: metadataVersion }
+          ...lastActivity
         });
-        return await callbacks.onUpdateSecurityContext(newSecurityContext);
-      },
-      /** Apply a new system prompt and restart the agent process */
-      applySystemPrompt: async (prompt, context) => {
-        authorizeRequest(context, metadata.sharing, "admin");
-        if (!callbacks.onApplySystemPrompt) {
-          throw new Error("System prompt updates are not supported for this session");
-        }
-        return await callbacks.onApplySystemPrompt(prompt);
-      },
-      // ── Listener Registration ──
-      registerListener: async (callback, context) => {
-        authorizeRequest(context, metadata.sharing, "view");
-        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 {
-          const result = callback.onUpdate({
-            type: "update-session",
-            sessionId,
-            metadata: { value: metadata, version: metadataVersion },
-            agentState: { value: agentState, version: agentStateVersion }
-          });
-          if (result && typeof result.catch === "function") {
-            result.catch(() => {
-            });
-          }
-        } catch {
-        }
-        try {
-          const result = callback.onUpdate({
-            type: "activity",
-            sessionId,
-            ...lastActivity
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
           });
-          if (result && typeof result.catch === "function") {
-            result.catch(() => {
-            });
-          }
-        } catch {
         }
-        return { success: true, listenerId: listeners.length - 1 };
+      } catch {
       }
-    },
-    { overwrite: true }
-  );
-  console.log(`[HYPHA SESSION] Session service registered: ${serviceInfo.id}`);
-  return {
-    serviceInfo,
+      return { success: true, listenerId: listeners.length - 1 };
+    }
+  };
+  const store = {
+    serviceInfo: { id: `svamp-session-${sessionId}` },
     pushMessage,
     get _agentState() {
       return agentState;
@@ -1315,9 +1380,44 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
       for (const listener of toRemove) {
         removeListener(listener, "disconnect");
       }
-      await server.unregisterService(serviceInfo.id);
+    },
+    reregister: async () => {
     }
   };
+  return { store, rpcHandlers };
+}
+async function registerSessionService(server, sessionId, initialMetadata, initialAgentState, callbacks, options) {
+  const { store, rpcHandlers } = createSessionStore(
+    server,
+    sessionId,
+    initialMetadata,
+    initialAgentState,
+    callbacks,
+    options
+  );
+  const serviceDefinition = {
+    id: `svamp-session-${sessionId}`,
+    name: `Svamp Session ${sessionId.slice(0, 8)}`,
+    type: "svamp-session",
+    config: { visibility: "unlisted", require_context: true },
+    ...rpcHandlers
+  };
+  const serviceInfo = await server.registerService(serviceDefinition, { overwrite: true });
+  console.log(`[HYPHA SESSION] Session service registered: ${serviceInfo.id}`);
+  const originalDisconnect = store.disconnect;
+  store.disconnect = async () => {
+    await originalDisconnect();
+    await server.unregisterService(serviceInfo.id);
+  };
+  store.reregister = async () => {
+    try {
+      await server.registerService(serviceDefinition, { overwrite: true });
+    } catch (e) {
+      if (!String(e?.message).includes("already exists")) throw e;
+    }
+  };
+  store.serviceInfo = serviceInfo;
+  return store;
 }
 
 async function registerDebugService(server, machineId, deps) {
@@ -1796,6 +1896,10 @@ function wrapWithNono(command, args, config) {
     if (existsSync(realLocalDir)) {
       nonoArgs.push("--read", realLocalDir);
     }
+    const realKeychainDir = join$1(homedir(), "Library", "Keychains");
+    if (existsSync(realKeychainDir)) {
+      nonoArgs.push("--read", realKeychainDir);
+    }
   }
   if (config.nonoConfig?.allowDirs) {
     for (const dir of config.nonoConfig.allowDirs) {
@@ -3886,9 +3990,8 @@ async function stageCredentialsForSharing(sessionId) {
   const realHome = homedir();
   const realClaudeDir = join$1(realHome, ".claude");
   await mkdir(STAGED_HOMES_DIR, { recursive: true });
-  const tmpHome = await mkdtemp(
-    join$1(STAGED_HOMES_DIR, `${sessionId.slice(0, 8)}-`)
-  );
+  const tmpHome = join$1(STAGED_HOMES_DIR, sessionId);
+  await mkdir(tmpHome, { recursive: true });
   const stagedClaudeDir = join$1(tmpHome, ".claude");
   await mkdir(stagedClaudeDir, { recursive: true });
   const credentialFiles = ["credentials.json", ".credentials.json"];
@@ -3909,10 +4012,12 @@ async function stageCredentialsForSharing(sessionId) {
     );
   } catch {
   }
-  const { writeFile } = await import('node:fs/promises');
-  try {
-    await writeFile(join$1(tmpHome, ".claude.json"), "{}");
-  } catch {
+  const claudeJsonPath = join$1(tmpHome, ".claude.json");
+  if (!existsSync(claudeJsonPath)) {
+    try {
+      await writeFile(claudeJsonPath, "{}");
+    } catch {
+    }
   }
   return {
     homePath: tmpHome,
@@ -4154,7 +4259,7 @@ class ProcessSupervisor {
   async persistSpec(spec) {
     const filePath = path.join(this.persistDir, `${spec.id}.json`);
     const tmpPath = filePath + ".tmp";
-    await writeFile(tmpPath, JSON.stringify(spec, null, 2), "utf-8");
+    await writeFile$1(tmpPath, JSON.stringify(spec, null, 2), "utf-8");
     await rename(tmpPath, filePath);
   }
   async deleteSpec(id) {
@@ -5313,6 +5418,7 @@ async function startDaemon(options) {
       serverUrl: hyphaServerUrl,
       token: hyphaToken,
       name: `svamp-machine-${machineId}`,
+      transport: "http",
       ...hyphaClientId ? { clientId: hyphaClientId } : {}
     });
     logger.log(`Connected to Hypha (workspace: ${server.config.workspace})`);
@@ -5320,6 +5426,7 @@ async function startDaemon(options) {
       logger.log(`Hypha connection permanently lost: ${reason}`);
       requestShutdown("hypha-disconnected", String(reason));
     });
+    const pidToTrackedSession = /* @__PURE__ */ new Map();
     server.on("services_registered", () => {
       if (consecutiveHeartbeatFailures > 0) {
         logger.log(`Hypha reconnection successful \u2014 services re-registered (resetting ${consecutiveHeartbeatFailures} failures)`);
@@ -5327,7 +5434,6 @@ async function startDaemon(options) {
         lastReconnectAt = Date.now();
       }
     });
-    const pidToTrackedSession = /* @__PURE__ */ new Map();
     const getCurrentChildren = () => {
       return Array.from(pidToTrackedSession.values()).map((s) => ({
         sessionId: s.svampSessionId || `PID-${s.pid}`,
@@ -5337,6 +5443,7 @@ async function startDaemon(options) {
         active: !s.stopped && s.hyphaService != null
       }));
     };
+    let machineServiceRef = null;
     const spawnSession = async (options2) => {
       logger.log("Spawning session:", JSON.stringify(options2));
       const { directory, approvedNewDirectoryCreation = true, resumeSessionId } = options2;
@@ -5479,6 +5586,9 @@ async function startDaemon(options) {
         let sessionWasProcessing = !!options2.wasProcessing;
         let lastAssistantText = "";
         let spawnHasReceivedInit = false;
+        let startupFailureRetryPending = false;
+        let startupRetryMessage;
+        let startupNonJsonLines = [];
         const signalProcessing = (processing) => {
           sessionService.sendKeepAlive(processing);
           const newState = processing ? "running" : "idle";
@@ -5529,6 +5639,8 @@ async function startDaemon(options) {
         let isolationCleanupFiles = [];
         const spawnClaude = (initialMessage, meta) => {
           const effectiveMeta = { ...lastSpawnMeta, ...meta };
+          startupNonJsonLines = [];
+          startupRetryMessage = initialMessage;
           let rawPermissionMode = effectiveMeta.permissionMode || agentConfig.default_permission_mode || currentPermissionMode;
           if (options2.forceIsolation || sessionMetadata.sharing?.enabled) {
             rawPermissionMode = rawPermissionMode === "default" ? "auto-approve-all" : rawPermissionMode;
@@ -5724,23 +5836,36 @@ async function startDaemon(options) {
                     if (msg.is_error) {
                       const resultText = msg.result || "";
                       logger.error(`[Session ${sessionId}] Claude error (is_error=true, api_ms=${msg.duration_api_ms}): "${resultText}"`);
-                      const lower = resultText.toLowerCase();
-                      const isLoginIssue = lower.includes("login") || lower.includes("logged in") || lower.includes("auth") || lower.includes("api key") || lower.includes("unauthorized");
-                      const isResumeIssue = lower.includes("tool_use.name") || lower.includes("invalid_request") || lower.includes("messages.");
-                      let hint = "";
-                      if (isLoginIssue) {
-                        hint = "\n\nRun `claude login` in your terminal on the machine running the daemon to re-authenticate.";
-                      } else if (isResumeIssue) {
-                        hint = "\n\nThe conversation history may be corrupted. Try starting a fresh session.";
+                      const isStartupFailure = msg.duration_api_ms === 0 && msg.num_turns === 0;
+                      if (isStartupFailure && !startupFailureRetryPending) {
+                        logger.log(`[Session ${sessionId}] Startup failure detected \u2014 scheduling silent retry without --resume`);
+                        startupFailureRetryPending = true;
+                        lastErrorMessagePushed = true;
                       } else {
-                        hint = "\n\nCheck that the Claude Code CLI is properly installed and configured.";
+                        const lower = resultText.toLowerCase();
+                        const isLoginIssue = lower.includes("login") || lower.includes("logged in") || lower.includes("auth") || lower.includes("api key") || lower.includes("unauthorized");
+                        const isResumeIssue = lower.includes("tool_use.name") || lower.includes("invalid_request") || lower.includes("messages.");
+                        const isBillingIssue = lower.includes("credit") || lower.includes("balance") || lower.includes("billing") || lower.includes("quota") || lower.includes("subscription") || lower.includes("payment");
+                        let hint = "";
+                        if (isBillingIssue) {
+                          hint = "\n\nCheck your Claude account credits or subscription at https://console.anthropic.com.";
+                        } else if (isLoginIssue) {
+                          hint = "\n\nRun `claude login` in your terminal on the machine running the daemon to re-authenticate.";
+                        } else if (isResumeIssue) {
+                          hint = "\n\nThe conversation history may be corrupted. Try starting a fresh session.";
+                        } else {
+                          hint = "\n\nCheck that the Claude Code CLI is properly installed and configured.";
+                        }
+                        const displayMsg = resultText || "Claude Code exited with an error.";
+                        let contextInfo = "";
+                        if (startupNonJsonLines.length > 0) {
+                          contextInfo = "\n\n**Startup output:**\n```\n" + startupNonJsonLines.slice(-10).join("\n") + "\n```";
+                        }
+                        const errorText = `${displayMsg}${hint}${contextInfo}`;
+                        logger.log(`[Session ${sessionId}] Pushing error to UI: "${displayMsg}"`);
+                        sessionService.pushMessage({ type: "message", message: errorText, level: "error" }, "event");
+                        lastErrorMessagePushed = true;
                       }
-                      const displayMsg = resultText || "Claude Code exited with an error.";
-                      sessionService.pushMessage({
-                        type: "assistant",
-                        content: [{ type: "text", text: `**Error:** ${displayMsg}${hint}` }]
-                      }, "agent");
-                      lastErrorMessagePushed = true;
                     }
                   }
                   if (msg.type === "result") {
@@ -5955,6 +6080,7 @@ The automated loop has finished. Review the progress above and let me know if yo
                     const isResumeFailure = !spawnHasReceivedInit && claudeResumeId && msg.session_id !== claudeResumeId;
                     const isConversationClear = spawnHasReceivedInit && claudeResumeId && msg.session_id !== claudeResumeId;
                     spawnHasReceivedInit = true;
+                    startupFailureRetryPending = false;
                     claudeResumeId = msg.session_id;
                     sessionMetadata = { ...sessionMetadata, claudeSessionId: msg.session_id };
                     sessionService.updateMetadata(sessionMetadata);
@@ -5996,6 +6122,9 @@ The automated loop has finished. Review the progress above and let me know if yo
                 }
               } catch {
                 logger.log(`[Session ${sessionId}] Claude stdout (non-JSON): ${line}`);
+                if (!spawnHasReceivedInit) {
+                  startupNonJsonLines.push(line.slice(0, 500));
+                }
               }
             }
           });
@@ -6040,6 +6169,19 @@ The automated loop has finished. Review the progress above and let me know if yo
             sessionMetadata = { ...sessionMetadata, lifecycleState: claudeResumeId ? "idle" : "stopped" };
             sessionService.updateMetadata(sessionMetadata);
             sessionWasProcessing = false;
+            if (startupFailureRetryPending && !trackedSession.stopped) {
+              startupFailureRetryPending = false;
+              const prevResumeId = claudeResumeId;
+              claudeResumeId = void 0;
+              logger.log(`[Session ${sessionId}] Startup failure \u2014 cleared stale resume ID (was: ${prevResumeId})`);
+              if (startupRetryMessage !== void 0) {
+                logger.log(`[Session ${sessionId}] Retrying startup without --resume`);
+                sessionMetadata = { ...sessionMetadata, lifecycleState: "running" };
+                sessionService.updateMetadata(sessionMetadata);
+                spawnClaude(startupRetryMessage);
+                return;
+              }
+            }
             const queueLen = sessionMetadata.messageQueue?.length ?? 0;
             if (queueLen > 0 && claudeResumeId && !trackedSession.stopped) {
               signalProcessing(false);
@@ -6115,7 +6257,7 @@ The automated loop has finished. Review the progress above and let me know if yo
           }
         }
         let processMessageQueueRef;
-        const sessionService = await registerSessionService(
+        const { store: sessionService, rpcHandlers: sessionRPCHandlers } = createSessionStore(
           server,
           sessionId,
           sessionMetadata,
@@ -6298,6 +6440,7 @@ The automated loop has finished. Review the progress above and let me know if yo
               stopSession(sessionId);
             },
             onMetadataUpdate: (newMeta) => {
+              const prevRalphLoop = sessionMetadata.ralphLoop;
               sessionMetadata = {
                 ...newMeta,
                 // Daemon drives lifecycleState — don't let frontend overwrite with stale value
@@ -6305,8 +6448,16 @@ The automated loop has finished. Review the progress above and let me know if yo
                 // 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 } : {}
+                ...sessionMetadata.sessionLink && !newMeta.sessionLink ? { sessionLink: sessionMetadata.sessionLink } : {},
+                // Preserve parentSessionId — set at spawn time, frontend may not track it
+                ...sessionMetadata.parentSessionId ? { parentSessionId: sessionMetadata.parentSessionId } : {},
+                // Preserve daemon-owned ralphLoop — frontend may send stale snapshot without it,
+                // which would wipe the active loop state and cause the bar to disappear mid-run.
+                ...prevRalphLoop ? { ralphLoop: prevRalphLoop } : {}
               };
+              if (prevRalphLoop && !newMeta.ralphLoop) {
+                sessionService.updateMetadata(sessionMetadata);
+              }
               const queue = newMeta.messageQueue;
               if (queue && queue.length > 0 && !sessionWasProcessing && !trackedSession.stopped) {
                 setTimeout(() => {
@@ -6407,7 +6558,7 @@ The automated loop has finished. Review the progress above and let me know if yo
               return { success: !!tree, tree };
             }
           },
-          { messagesDir: getSessionDir(directory, sessionId) }
+          { messagesDir: getSessionDir(directory, sessionId), onSessionEvent: (update) => machineServiceRef?.notifySessionEvent(update) }
         );
         const svampConfig = createSvampConfigChecker(
           directory,
@@ -6494,6 +6645,7 @@ The automated loop has finished. Review the progress above and let me know if yo
           pid: process.pid,
           svampSessionId: sessionId,
           hyphaService: sessionService,
+          sessionRPCHandlers,
           checkSvampConfig,
           cleanupSvampConfig,
           directory,
@@ -6579,7 +6731,7 @@ The automated loop has finished. Review the progress above and let me know if yo
         const allowedBashLiterals = /* @__PURE__ */ new Set();
         const allowedBashPrefixes = /* @__PURE__ */ new Set();
         const EDIT_TOOLS = /* @__PURE__ */ new Set(["Edit", "MultiEdit", "Write", "NotebookEdit"]);
-        const sessionService = await registerSessionService(
+        const { store: sessionService, rpcHandlers: sessionRPCHandlersAcp } = createSessionStore(
           server,
           sessionId,
           sessionMetadata,
@@ -6691,13 +6843,22 @@ The automated loop has finished. Review the progress above and let me know if yo
               stopSession(sessionId);
             },
             onMetadataUpdate: (newMeta) => {
+              const prevRalphLoop = sessionMetadata.ralphLoop;
               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 } : {}
+                ...sessionMetadata.sessionLink && !newMeta.sessionLink ? { sessionLink: sessionMetadata.sessionLink } : {},
+                // Preserve parentSessionId — set at spawn time, frontend may not track it
+                ...sessionMetadata.parentSessionId ? { parentSessionId: sessionMetadata.parentSessionId } : {},
+                // Preserve daemon-owned ralphLoop — frontend may send stale snapshot without it,
+                // which would wipe the active loop state and cause the bar to disappear mid-run.
+                ...prevRalphLoop ? { ralphLoop: prevRalphLoop } : {}
               };
+              if (prevRalphLoop && !newMeta.ralphLoop) {
+                sessionService.updateMetadata(sessionMetadata);
+              }
               if (acpStopped) return;
               const queue = newMeta.messageQueue;
               if (queue && queue.length > 0 && sessionMetadata.lifecycleState === "idle") {
@@ -6809,7 +6970,7 @@ The automated loop has finished. Review the progress above and let me know if yo
               return { success: !!tree, tree };
             }
           },
-          { messagesDir: getSessionDir(directory, sessionId) }
+          { messagesDir: getSessionDir(directory, sessionId), onSessionEvent: (update) => machineServiceRef?.notifySessionEvent(update) }
         );
         let insideOnTurnEnd = false;
         const svampConfigChecker = createSvampConfigChecker(
@@ -7031,6 +7192,7 @@ The automated loop has finished. Review the progress above and let me know if yo
           pid: process.pid,
           svampSessionId: sessionId,
           hyphaService: sessionService,
+          sessionRPCHandlers: sessionRPCHandlersAcp,
           checkSvampConfig,
           cleanupSvampConfig: svampConfigChecker.cleanup,
           directory,
@@ -7156,10 +7318,28 @@ The automated loop has finished. Review the progress above and let me know if yo
         restartSession,
         requestShutdown: () => requestShutdown("hypha-app"),
         getTrackedSessions: getCurrentChildren,
+        getSessionRPCHandlers: (sessionId) => {
+          for (const [, session] of pidToTrackedSession) {
+            if (session.svampSessionId === sessionId && session.sessionRPCHandlers) {
+              return session.sessionRPCHandlers;
+            }
+          }
+          return void 0;
+        },
+        getSessionIds: () => {
+          const ids = [];
+          for (const [, session] of pidToTrackedSession) {
+            if (session.svampSessionId && !session.stopped && session.sessionRPCHandlers) {
+              ids.push(session.svampSessionId);
+            }
+          }
+          return ids;
+        },
         supervisor
       }
     );
     logger.log(`Machine service registered: svamp-machine-${machineId}`);
+    machineServiceRef = machineService;
     const artifactSync = new SessionArtifactSync(server, logger.log);
     const debugService = await registerDebugService(server, machineId, {
       machineId,
@@ -7347,7 +7527,7 @@ The automated loop has finished. Review the progress above and let me know if yo
     console.log(`  Service: svamp-machine-${machineId}`);
     console.log(`  Log file: ${logger.logFilePath}`);
     const HEARTBEAT_INTERVAL_MS = 1e4;
-    const PING_TIMEOUT_MS = 15e3;
+    const PING_TIMEOUT_MS = 6e4;
     const MAX_FAILURES = 60;
     const POST_RECONNECT_GRACE_MS = 2e4;
     let heartbeatRunning = false;
@@ -7431,6 +7611,13 @@ The automated loop has finished. Review the progress above and let me know if yo
                 } catch {
                 }
               }
+              if (conn?._reader) {
+                logger.log("Aborting stale HTTP stream to trigger reconnection");
+                try {
+                  conn._reader.cancel?.("Stale connection");
+                } catch {
+                }
+              }
             }
             if (consecutiveHeartbeatFailures >= MAX_FAILURES) {
               logger.log(`Heartbeat failed ${MAX_FAILURES} times. Shutting down.`);