svamp-cli 0.1.69 → 0.1.70

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { b as stopDaemon, s as startDaemon, d as daemonStatus } from './run-DxmtlxnM.mjs';
+import { b as stopDaemon, s as startDaemon, d as daemonStatus } from './run-C7CEDmD4.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';
@@ -109,7 +109,7 @@ async function main() {
     const { handleServiceCommand } = await import('./commands-CF32XIau.mjs');
     await handleServiceCommand();
   } else if (subcommand === "process" || subcommand === "proc") {
-    const { processCommand } = await import('./commands-CNWZF0B9.mjs');
+    const { processCommand } = await import('./commands-CIgrbviM.mjs');
     let machineId;
     const processArgs = args.slice(1);
     const mIdx = processArgs.findIndex((a) => a === "--machine" || a === "-m");
@@ -127,7 +127,7 @@ async function main() {
   } else if (!subcommand || subcommand === "start") {
     await handleInteractiveCommand();
   } else if (subcommand === "--version" || subcommand === "-v") {
-    const pkg = await import('./package-D2QVDgm_.mjs').catch(() => ({ default: { version: "unknown" } }));
+    const pkg = await import('./package-B0d2rUXI.mjs').catch(() => ({ default: { version: "unknown" } }));
     console.log(`svamp version: ${pkg.default.version}`);
   } else {
     console.error(`Unknown command: ${subcommand}`);
@@ -136,7 +136,7 @@ async function main() {
   }
 }
 async function handleInteractiveCommand() {
-  const { runInteractive } = await import('./run-DqPEyYsf.mjs');
+  const { runInteractive } = await import('./run-CgSj6KtU.mjs');
   const interactiveArgs = subcommand === "start" ? args.slice(1) : args;
   let directory = process.cwd();
   let resumeSessionId;
@@ -181,7 +181,7 @@ async function handleAgentCommand() {
     return;
   }
   if (agentArgs[0] === "list") {
-    const { KNOWN_ACP_AGENTS, KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS2 } = await import('./run-DxmtlxnM.mjs').then(function (n) { return n.i; });
+    const { KNOWN_ACP_AGENTS, KNOWN_MCP_AGENTS: KNOWN_MCP_AGENTS2 } = await import('./run-C7CEDmD4.mjs').then(function (n) { return n.i; });
     console.log("Known agents:");
     for (const [name, config2] of Object.entries(KNOWN_ACP_AGENTS)) {
       console.log(`  ${name.padEnd(12)} ${config2.command} ${config2.args.join(" ")}  (ACP)`);
@@ -193,7 +193,7 @@ async function handleAgentCommand() {
     console.log('Use "svamp agent -- <command> [args]" for a custom ACP agent.');
     return;
   }
-  const { resolveAcpAgentConfig, KNOWN_MCP_AGENTS } = await import('./run-DxmtlxnM.mjs').then(function (n) { return n.i; });
+  const { resolveAcpAgentConfig, KNOWN_MCP_AGENTS } = await import('./run-C7CEDmD4.mjs').then(function (n) { return n.i; });
   let cwd = process.cwd();
   const filteredArgs = [];
   for (let i = 0; i < agentArgs.length; i++) {
@@ -217,12 +217,12 @@ async function handleAgentCommand() {
   console.log(`Starting ${config.agentName} agent in ${cwd}...`);
   let backend;
   if (KNOWN_MCP_AGENTS[config.agentName]) {
-    const { CodexMcpBackend } = await import('./run-DxmtlxnM.mjs').then(function (n) { return n.j; });
+    const { CodexMcpBackend } = await import('./run-C7CEDmD4.mjs').then(function (n) { return n.j; });
     backend = new CodexMcpBackend({ cwd, log: logFn });
   } else {
-    const { AcpBackend } = await import('./run-DxmtlxnM.mjs').then(function (n) { return n.h; });
-    const { GeminiTransport } = await import('./run-DxmtlxnM.mjs').then(function (n) { return n.G; });
-    const { DefaultTransport } = await import('./run-DxmtlxnM.mjs').then(function (n) { return n.D; });
+    const { AcpBackend } = await import('./run-C7CEDmD4.mjs').then(function (n) { return n.h; });
+    const { GeminiTransport } = await import('./run-C7CEDmD4.mjs').then(function (n) { return n.G; });
+    const { DefaultTransport } = await import('./run-C7CEDmD4.mjs').then(function (n) { return n.D; });
     const transportHandler = config.agentName === "gemini" ? new GeminiTransport() : new DefaultTransport(config.agentName);
     backend = new AcpBackend({
       agentName: config.agentName,
@@ -340,7 +340,7 @@ async function handleSessionCommand() {
     printSessionHelp();
     return;
   }
-  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach, sessionMachines, sessionSend, sessionWait, sessionShare, sessionRalphStart, sessionRalphCancel, sessionRalphStatus, sessionQueueAdd, sessionQueueList, sessionQueueClear } = await import('./commands-CgWkG45c.mjs');
+  const { sessionList, sessionSpawn, sessionStop, sessionInfo, sessionMessages, sessionAttach, sessionMachines, sessionSend, sessionWait, sessionShare, sessionRalphStart, sessionRalphCancel, sessionRalphStatus, sessionQueueAdd, sessionQueueList, sessionQueueClear } = await import('./commands-BodoXVL9.mjs');
   const parseFlagStr = (flag, shortFlag) => {
     for (let i = 1; i < sessionArgs.length; i++) {
       if ((sessionArgs[i] === flag || shortFlag) && i + 1 < sessionArgs.length) {
@@ -400,7 +400,7 @@ async function handleSessionCommand() {
         allowDomain.push(sessionArgs[++i]);
       }
     }
-    const { parseShareArg } = await import('./commands-CgWkG45c.mjs');
+    const { parseShareArg } = await import('./commands-BodoXVL9.mjs');
     const shareEntries = share.map((s) => parseShareArg(s));
     await sessionSpawn(agent, dir, targetMachineId, {
       message,
@@ -484,7 +484,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session approve <session-id> [request-id] [--json]");
       process.exit(1);
     }
-    const { sessionApprove } = await import('./commands-CgWkG45c.mjs');
+    const { sessionApprove } = await import('./commands-BodoXVL9.mjs');
     const approveReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
     await sessionApprove(sessionArgs[1], approveReqId, targetMachineId, {
       json: hasFlag("--json")
@@ -494,7 +494,7 @@ async function handleSessionCommand() {
       console.error("Usage: svamp session deny <session-id> [request-id] [--json]");
       process.exit(1);
     }
-    const { sessionDeny } = await import('./commands-CgWkG45c.mjs');
+    const { sessionDeny } = await import('./commands-BodoXVL9.mjs');
     const denyReqId = sessionArgs[2] && !sessionArgs[2].startsWith("--") ? sessionArgs[2] : void 0;
     await sessionDeny(sessionArgs[1], denyReqId, targetMachineId, {
       json: hasFlag("--json")
@@ -597,7 +597,7 @@ async function handleMachineCommand() {
     return;
   }
   if (machineSubcommand === "share") {
-    const { machineShare } = await import('./commands-CgWkG45c.mjs');
+    const { machineShare } = await import('./commands-BodoXVL9.mjs');
     let machineId;
     const shareArgs = [];
     for (let i = 1; i < machineArgs.length; i++) {
@@ -627,7 +627,7 @@ async function handleMachineCommand() {
     }
     await machineShare(machineId, { add, remove, list, configPath, showConfig });
   } else if (machineSubcommand === "exec") {
-    const { machineExec } = await import('./commands-CgWkG45c.mjs');
+    const { machineExec } = await import('./commands-BodoXVL9.mjs');
     let machineId;
     let cwd;
     const cmdParts = [];
@@ -647,7 +647,7 @@ async function handleMachineCommand() {
     }
     await machineExec(machineId, command, cwd);
   } else if (machineSubcommand === "info") {
-    const { machineInfo } = await import('./commands-CgWkG45c.mjs');
+    const { machineInfo } = await import('./commands-BodoXVL9.mjs');
     let machineId;
     for (let i = 1; i < machineArgs.length; i++) {
       if ((machineArgs[i] === "--machine" || machineArgs[i] === "-m") && i + 1 < machineArgs.length) {
@@ -670,7 +670,7 @@ async function handleMachineCommand() {
     const { machineNotify } = await import('./agentCommands-C6iGblcL.mjs');
     await machineNotify(message, level);
   } else if (machineSubcommand === "ls") {
-    const { machineLs } = await import('./commands-CgWkG45c.mjs');
+    const { machineLs } = await import('./commands-BodoXVL9.mjs');
     let machineId;
     let showHidden = false;
     let path;

package/dist/{commands-CgWkG45c.mjs → commands-BodoXVL9.mjs}

@@ -2,7 +2,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { resolve, join } from 'node:path';
 import os from 'node:os';
-import { l as loadSecurityContextConfig, e as resolveSecurityContext, f as buildSecurityContextFromFlags, m as mergeSecurityContexts, c as connectToHypha } from './run-DxmtlxnM.mjs';
+import { l as loadSecurityContextConfig, e as resolveSecurityContext, f as buildSecurityContextFromFlags, m as mergeSecurityContexts, c as connectToHypha } from './run-C7CEDmD4.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{commands-CNWZF0B9.mjs → commands-CIgrbviM.mjs}

@@ -1,11 +1,11 @@
 import { writeFileSync, readFileSync } from 'fs';
 import { resolve } from 'path';
-import { connectAndGetMachine } from './commands-CgWkG45c.mjs';
+import { connectAndGetMachine } from './commands-BodoXVL9.mjs';
 import 'node:fs';
 import 'node:child_process';
 import 'node:path';
 import 'node:os';
-import './run-DxmtlxnM.mjs';
+import './run-C7CEDmD4.mjs';
 import 'os';
 import 'fs/promises';
 import 'url';

package/dist/index.mjs

@@ -1,4 +1,4 @@
-export { c as connectToHypha, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, a as registerSessionService, s as startDaemon, b as stopDaemon } from './run-DxmtlxnM.mjs';
+export { c as connectToHypha, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, a as registerSessionService, s as startDaemon, b as stopDaemon } from './run-C7CEDmD4.mjs';
 import 'os';
 import 'fs/promises';
 import 'fs';

package/dist/{package-D2QVDgm_.mjs → package-B0d2rUXI.mjs}

@@ -1,5 +1,5 @@
 var name = "svamp-cli";
-var version = "0.1.69";
+var version = "0.1.70";
 var description = "Svamp CLI — AI workspace daemon on Hypha Cloud";
 var author = "Amun AI AB";
 var license = "SEE LICENSE IN LICENSE";

package/dist/{run-DxmtlxnM.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) {
@@ -5320,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}`,
@@ -5479,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";
@@ -5529,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;
@@ -5724,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") {
@@ -5955,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);
@@ -5996,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));
+                }
               }
             }
           });
@@ -6040,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);
@@ -6298,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
@@ -6305,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(() => {
@@ -6691,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") {
@@ -7347,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;

package/dist/{run-DqPEyYsf.mjs → run-CgSj6KtU.mjs}

@@ -2,7 +2,7 @@ import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(im
 import os from 'node:os';
 import { join, resolve } from 'node:path';
 import { mkdirSync, writeFileSync, existsSync, unlinkSync, readFileSync, watch } from 'node:fs';
-import { c as connectToHypha, a as registerSessionService } from './run-DxmtlxnM.mjs';
+import { c as connectToHypha, a as registerSessionService } from './run-C7CEDmD4.mjs';
 import { createServer } from 'node:http';
 import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.1.69",
+  "version": "0.1.70",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",