Merge pull request #782 from web3dev1337/fix/recovery-resume

fix: restore recovery auto-resume

Author: web3dev1337

client/app.js

@@ -13759,15 +13759,24 @@ class ClaudeOrchestrator {
     console.log('Applying session recovery:', recovery);
     const recoverySettings = this.userSettings?.global?.sessionRecovery || {};
     const resumeConversation = recoverySettings.resumeConversation !== false;
+    const resumeCwd = recoverySettings.resumeCwd !== false;
+    const normalizeMode = (mode, fallback) => {
+      const normalized = String(mode || '').trim().toLowerCase();
+      if (normalized === 'fresh' || normalized === 'continue' || normalized === 'resume') {
+        return normalized;
+      }
+      return fallback;
+    };
 
     // Track which sessions we're recovering so auto-start skips them
     this.recoveredSessions = new Set();
 
     for (const session of recovery.sessions) {
-      const { sessionId, lastCwd, lastAgent, lastConversationId } = session;
+      const { sessionId, lastCwd, lastAgent, lastConversationId, lastMode } = session;
 
       // Find the terminal for this session
-      if (!this.sessions.has(sessionId)) {
+      const sessionState = this.sessions.get(sessionId);
+      if (!sessionState) {
         console.log(`Session ${sessionId} not found, skipping recovery`);
         continue;
       }
@@ -13777,24 +13786,53 @@ class ClaudeOrchestrator {
 
       console.log(`Recovering session ${sessionId}:`, { lastCwd, lastAgent, lastConversationId });
 
-      // Start agent with resume if conversation available and it's a claude terminal
-      if (resumeConversation && lastConversationId && lastAgent === 'claude' && sessionId.includes('-claude')) {
-        console.log(`Resuming conversation: ${lastConversationId} in ${lastCwd}`);
+      const sessionType = String(sessionState?.type || '').trim().toLowerCase();
+      const recoveryCwd = resumeCwd ? lastCwd : null;
 
-        // Use recovery-specific skipPermissions setting (defaults to true)
+      if (lastAgent === 'claude' && (sessionType === 'claude' || sessionId.includes('-claude'))) {
         const skipPermissions = recoverySettings.skipPermissions !== false;
+        if (resumeConversation && lastConversationId) {
+          console.log(`Resuming conversation: ${lastConversationId} in ${lastCwd}`);
+          this.socket.emit('start-claude', {
+            sessionId,
+            options: {
+              mode: 'resume',
+              resumeId: lastConversationId,
+              skipPermissions: skipPermissions,
+              cwd: recoveryCwd
+            }
+          });
+        } else {
+          let mode = normalizeMode(lastMode, 'continue');
+          if (mode === 'resume') mode = 'continue';
+          console.log(`Recovering Claude session ${sessionId} with mode: ${mode}`);
+          this.socket.emit('start-claude', {
+            sessionId,
+            options: {
+              mode,
+              skipPermissions: skipPermissions,
+              cwd: recoveryCwd
+            }
+          });
+        }
 
-        this.socket.emit('start-claude', {
-          sessionId,
-          options: {
-            mode: 'resume',
-            resumeId: lastConversationId,
-            skipPermissions: skipPermissions,
-            cwd: lastCwd
-          }
-        });
+        await new Promise(resolve => setTimeout(resolve, 200));
+        continue;
+      }
 
-        // Small delay between sessions
+      if (lastAgent === 'codex') {
+        let mode = normalizeMode(lastMode, 'continue');
+        if (mode === 'resume') mode = 'continue';
+        console.log(`Recovering Codex session ${sessionId} with mode: ${mode}`);
+        const config = {
+          agentId: 'codex',
+          mode,
+          flags: ['yolo']
+        };
+        if (recoveryCwd) {
+          config.cwd = recoveryCwd;
+        }
+        await this.startAgentWithConfig(sessionId, config);
         await new Promise(resolve => setTimeout(resolve, 200));
       }
     }

server/sessionManager.js

@@ -873,7 +873,7 @@ class SessionManager extends EventEmitter {
           // make the UI think an AI is still attached/running.
           if (workspaceId) {
             try {
-              sessionRecoveryService.clearAgent(workspaceId, sessionId);
+              sessionRecoveryService.markAgentInactive(workspaceId, sessionId);
             } catch {
               // best-effort
             }
@@ -1988,7 +1988,10 @@ class SessionManager extends EventEmitter {
     const recovery = workspaceId
       ? sessionRecoveryService.getSession(workspaceId, sessionId)
       : null;
-    const agent = recovery?.lastAgent || (type === 'codex' ? 'codex' : null);
+    const agentActive = recovery?.lastAgentActive !== false;
+    const agent = agentActive
+      ? (recovery?.lastAgent || (type === 'codex' ? 'codex' : null))
+      : null;
 
     const newStatus = this.statusDetector.detectStatus(sessionId, session.buffer || '', { agent });
     if (newStatus === 'idle' && workspaceId && recovery?.lastAgent) {
@@ -1998,7 +2001,7 @@ class SessionManager extends EventEmitter {
       const recentAll = this.statusDetector.getLastNonEmptyLines(recentLines, 6).join('\n');
       if (this.statusDetector.hasExplicitShellIndicator(recentAll, lastNonEmptyLine)) {
         try {
-          sessionRecoveryService.clearAgent(workspaceId, sessionId);
+          sessionRecoveryService.markAgentInactive(workspaceId, sessionId);
         } catch {
           // best-effort cleanup; status update still proceeds
         }
@@ -2153,7 +2156,7 @@ class SessionManager extends EventEmitter {
         worktreeId: session.worktreeId,
         repositoryName: session.repositoryName,  // For mixed-repo workspaces
         repositoryType: session.repositoryType,  // For dynamic launch options
-        agent: recovery?.lastAgent || null,
+        agent: recovery?.lastAgentActive === false ? null : (recovery?.lastAgent || null),
         agentMode: recovery?.lastMode || null,
         lastActivity: session.lastActivity
       };
@@ -2670,7 +2673,7 @@ class SessionManager extends EventEmitter {
       const workspaceId = session.workspace || null;
       if (workspaceId) {
         try {
-          sessionRecoveryService.clearAgent(workspaceId, sessionId);
+          sessionRecoveryService.markAgentInactive(workspaceId, sessionId);
         } catch {
           // best-effort
         }

server/sessionRecoveryService.js

@@ -198,7 +198,8 @@ class SessionRecoveryService {
    */
   updateAgent(workspaceId, sessionId, agent, modeOrMeta) {
     const updates = {
-      lastAgent: agent  // 'claude', 'codex', 'opencode', etc.
+      lastAgent: agent,  // 'claude', 'codex', 'opencode', etc.
+      lastAgentActive: true
     };
 
     if (modeOrMeta && typeof modeOrMeta === 'object') {
@@ -216,6 +217,7 @@ class SessionRecoveryService {
   clearAgent(workspaceId, sessionId) {
     return this.updateSession(workspaceId, sessionId, {
       lastAgent: null,
+      lastAgentActive: false,
       lastMode: null,
       lastAgentCommand: null,
       lastAgentCwd: null,
@@ -224,6 +226,20 @@ class SessionRecoveryService {
     });
   }
 
+  /**
+   * Mark agent as inactive without losing the last agent metadata.
+   * Keeps recovery info intact while allowing the UI to show "no agent".
+   */
+  markAgentInactive(workspaceId, sessionId, meta = null) {
+    const updates = {
+      lastAgentActive: false
+    };
+    if (meta && typeof meta === 'object') {
+      Object.assign(updates, meta);
+    }
+    return this.updateSession(workspaceId, sessionId, updates);
+  }
+
   /**
    * Mark session as running a server
    */
@@ -333,21 +349,22 @@ class SessionRecoveryService {
         }
       }
 
-      // Only include Claude sessions with valid conversations
-      // Always include server sessions
+      const safeConversationId = (s.lastAgent === 'claude' && conversationValid)
+        ? s.lastConversationId
+        : null;
       if (s.lastAgent === 'claude' && !conversationValid) {
-        logger.debug('Skipping session with invalid/empty conversation', {
+        logger.debug('Recovery session missing valid conversation, falling back to continue', {
           sessionId: s.sessionId,
           conversationId: s.lastConversationId
         });
-        continue;
       }
 
       recoveryData.push({
         sessionId: s.sessionId,
         lastCwd: conversationCwd || s.worktreePath,
         lastAgent: s.lastAgent,
-        lastConversationId: s.lastConversationId,
+        lastMode: s.lastMode,
+        lastConversationId: safeConversationId,
         worktreePath: s.worktreePath,
         lastServerCommand: s.lastServerCommand,
         updatedAt: s.updatedAt