svamp-cli 0.1.68 → 0.1.70

package/dist/{run-DWFTrXVF.mjs → run-C7CEDmD4.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;
@@ -907,353 +907,351 @@ 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 serviceDefinition = {
+    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 };
         }
-        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(() => {
           });
-          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(() => {
-            });
-          }
-        } catch {
-        }
-        return { success: true, listenerId: listeners.length - 1 };
+      } catch {
       }
-    },
-    { overwrite: true }
-  );
+      return { success: true, listenerId: listeners.length - 1 };
+    }
+  };
+  const serviceInfo = await server.registerService(serviceDefinition, { overwrite: true });
   console.log(`[HYPHA SESSION] Session service registered: ${serviceInfo.id}`);
   return {
     serviceInfo,
@@ -1316,6 +1314,13 @@ async function registerSessionService(server, sessionId, initialMetadata, initia
         removeListener(listener, "disconnect");
       }
       await server.unregisterService(serviceInfo.id);
+    },
+    reregister: async () => {
+      try {
+        await server.registerService(serviceDefinition, { overwrite: true });
+      } catch (e) {
+        if (!String(e?.message).includes("already exists")) throw e;
+      }
     }
   };
 }
@@ -1796,6 +1801,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 +3895,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 +3917,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 +4164,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) {
@@ -4467,6 +4477,53 @@ async function installSkillFromMarketplace(name) {
     writeFileSync(localPath, content, "utf-8");
   }
 }
+function preventMachineSleep(logger) {
+  if (process.platform === "darwin") {
+    const caff = spawn$1("caffeinate", ["-s", "-i", "-m"], { stdio: "ignore", detached: false });
+    caff.on("error", (err) => {
+      logger.log(`Warning: could not start caffeinate to prevent sleep: ${err.message}`);
+    });
+    caff.on("exit", (code) => {
+      if (code !== null && code !== 0) {
+        logger.log(`Warning: caffeinate exited unexpectedly (code ${code})`);
+      }
+    });
+    process.on("exit", () => {
+      try {
+        caff.kill();
+      } catch {
+      }
+    });
+    logger.log("caffeinate started \u2014 machine will not sleep while daemon is running");
+    return;
+  }
+  if (process.platform === "linux") {
+    const inh = spawn$1(
+      "systemd-inhibit",
+      ["--what=idle:sleep:handle-lid-switch", "--who=svamp", "--why=Svamp daemon running", "--mode=block", "sleep", "infinity"],
+      { stdio: "ignore", detached: false }
+    );
+    inh.on("error", () => {
+    });
+    inh.on("exit", (code) => {
+      if (code !== null && code !== 0 && code !== 130) {
+        logger.log(`Warning: systemd-inhibit exited with code ${code} \u2014 sleep prevention may be inactive`);
+      }
+    });
+    process.on("exit", () => {
+      try {
+        inh.kill();
+      } catch {
+      }
+    });
+    setImmediate(() => {
+      if (!inh.killed && inh.exitCode === null) {
+        logger.log("systemd-inhibit started \u2014 machine will not idle-sleep while daemon is running");
+      }
+    });
+    return;
+  }
+}
 async function ensureAutoInstalledSkills(logger) {
   const tasks = [
     {
@@ -5159,8 +5216,12 @@ async function startDaemon(options) {
     // hypha-rpc connection closed message
     "Client disconnected",
     // Hypha client disconnect events
-    "fetch failed"
+    "fetch failed",
     // Fetch API errors during reconnect
+    "already exists in the cache store",
+    // hypha-rpc: stale in-flight RPC calls after reconnect try to resolve with duplicate message keys
+    "Failed to send the request when calling method"
+    // hypha-rpc: RPC call failed after reconnect (often wraps the cache store error)
   ];
   let unhandledRejectionCount = 0;
   let unhandledRejectionResetTimer = null;
@@ -5255,6 +5316,7 @@ async function startDaemon(options) {
   await supervisor.init();
   ensureAutoInstalledSkills(logger).catch(() => {
   });
+  preventMachineSleep(logger);
   try {
     logger.log("Connecting to Hypha server...");
     server = await connectToHypha({
@@ -5268,14 +5330,22 @@ 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)`);
         consecutiveHeartbeatFailures = 0;
         lastReconnectAt = Date.now();
       }
+      const activeSessions = Array.from(pidToTrackedSession.values()).filter((s) => !s.stopped && s.hyphaService);
+      if (activeSessions.length > 0) {
+        logger.log(`Re-registering ${activeSessions.length} session services after reconnect`);
+        Promise.allSettled(activeSessions.map((s) => s.hyphaService.reregister())).then((results) => {
+          const failed = results.filter((r) => r.status === "rejected").length;
+          if (failed > 0) logger.log(`Warning: ${failed} session service re-registrations failed`);
+        });
+      }
     });
-    const pidToTrackedSession = /* @__PURE__ */ new Map();
     const getCurrentChildren = () => {
       return Array.from(pidToTrackedSession.values()).map((s) => ({
         sessionId: s.svampSessionId || `PID-${s.pid}`,
@@ -5412,6 +5482,10 @@ async function startDaemon(options) {
           securityContext: options2.securityContext,
           tags: options2.tags,
           parentSessionId: options2.parentSessionId,
+          ...options2.parentSessionId && (() => {
+            const parentTracked = Array.from(pidToTrackedSession.values()).find((t) => t.svampSessionId === options2.parentSessionId);
+            return parentTracked?.directory ? { parentSessionPath: parentTracked.directory } : {};
+          })(),
           ...options2.injectPlatformGuidance !== void 0 && { injectPlatformGuidance: options2.injectPlatformGuidance }
         };
         let claudeProcess = null;
@@ -5423,6 +5497,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";
@@ -5473,6 +5550,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;
@@ -5668,23 +5747,34 @@ 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.");
+                        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.";
+                        } 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```";
+                        }
+                        sessionService.pushMessage({
+                          type: "assistant",
+                          content: [{ type: "text", text: `**Error:** ${displayMsg}${hint}${contextInfo}` }]
+                        }, "agent");
+                        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") {
@@ -5899,6 +5989,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);
@@ -5940,6 +6031,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));
+                }
               }
             }
           });
@@ -5984,6 +6078,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);
@@ -6242,6 +6349,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
@@ -6249,8 +6357,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(() => {
@@ -6635,13 +6751,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") {
@@ -7291,7 +7416,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;