Fix session resume by adding service-level retry on stale session

When the sandbox times out and loses its filesystem, the Claude Agent SDK
can't find the session file and the CLI exits with code 1 ("No conversation
found with session ID"). The executor's try/catch never runs because the
CLI calls process.exit(1) directly.

Service fix (handles old+new sandboxes):
- Detect "No conversation found" in stderr after execution failure
- Clear stale session ID from DB
- Re-run command without --continue (fresh session)

Executor fix (for new sandbox templates):
- Add unhandledRejection handler to suppress SDK async errors during resume
- Break out of for-await loop immediately on resume failure
- Don't stream error result to frontend during resume (prevents confusing
  "Task Failed" card before retry succeeds)
- Wait for SDK microtasks to settle before retry

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: bidah

apps/web/lib/claude-code-service.ts

@@ -496,6 +496,129 @@ export class ClaudeCodeService {
 
       const executionDuration = Date.now() - executionStartTime
 
+      // Detect session resume failure — retry without --continue
+      // The Claude Agent SDK stores sessions on the CLI's local filesystem.
+      // If the session file is gone (sandbox restart, SDK version mismatch, etc.),
+      // the CLI exits with "No conversation found with session ID: ..." and code 1.
+      const isSessionResumeFailure = request.sessionId && (
+        (execution?.stderr?.includes('No conversation found with session ID') ?? false) ||
+        (executionError?.message?.includes('exit status 1') && !completionDetected && stdoutChunkCount < 10)
+      )
+
+      if (isSessionResumeFailure) {
+        console.warn('[Claude Code Service] 🔄 Session resume failed — retrying without --continue', {
+          sessionId: request.sessionId,
+          stderr: execution?.stderr?.substring(0, 300),
+          exitCode: execution?.exitCode,
+        })
+
+        // Clear stale session ID from DB
+        try {
+          await db.update(projects)
+            .set({ conversationId: null, updatedAt: new Date() })
+            .where(eq(projects.id, request.projectId))
+          console.log('[Claude Code Service] Cleared stale session ID from DB')
+        } catch (dbError) {
+          console.error('[Claude Code Service] Failed to clear session ID:', dbError)
+        }
+
+        // Re-run the command without --continue (fresh session)
+        completionDetected = false
+        capturedSessionId = null
+        lineBuffer = ''
+        receivedAnyOutput = false
+        stdoutChunkCount = 0
+        stderrChunkCount = 0
+        execution = undefined
+        executionError = null
+
+        const retryCommand = `cd /claude-sdk && bun start -- --prompt="${escapedMessage}"${systemPromptArg}${modelArg}${imageUrlsArg}${convexDeployArg}`
+        console.log('[Claude Code Service] 🔄 Retrying with fresh session (no --continue)')
+
+        try {
+          const retryHandle = await sandbox.commands.run(
+            retryCommand,
+            {
+              background: true as const,
+              envs: { ANTHROPIC_API_KEY: apiKeyToUse },
+              timeoutMs: sandboxTimeoutMs,
+              onStdout: (data: string) => {
+                stdoutChunkCount++
+                receivedAnyOutput = true
+                lineBuffer += data
+
+                // Same parsing logic as original — extract streaming messages
+                try {
+                  const lines = lineBuffer.split('\n')
+                  lineBuffer = lines.pop() || ''
+
+                  for (const line of lines) {
+                    const trimmedLine = line.trim()
+                    if (trimmedLine === 'CLAUDE_CODE_COMPLETE') {
+                      completionDetected = true
+                      continue
+                    }
+                    if (line.includes('"type":"system"') && line.includes('"session_id"')) {
+                      try {
+                        const jsonMatch = line.match(/Streaming:\s*(\{.+\})/)
+                        if (jsonMatch) {
+                          const parsed = JSON.parse(jsonMatch[1])
+                          if (parsed.session_id && !capturedSessionId) {
+                            capturedSessionId = parsed.session_id
+                            console.log('[Claude Code Service] Captured session ID (retry):', capturedSessionId)
+                          }
+                        }
+                      } catch (e) { /* ignore */ }
+                    }
+                    if (line.includes('"type":"result"') && line.includes('"session_id"')) {
+                      try {
+                        const jsonMatch = line.match(/Streaming:\s*(\{.+\})/)
+                        if (jsonMatch) {
+                          const parsed = JSON.parse(jsonMatch[1])
+                          if (parsed.session_id && !capturedSessionId) {
+                            capturedSessionId = parsed.session_id
+                          }
+                        }
+                      } catch (e) { /* ignore */ }
+                    }
+                    if (trimmedLine && line.includes('Streaming:')) {
+                      const messageMatch = line.match(/Streaming:\s*(.+)/)
+                      if (messageMatch && messageMatch[1]) {
+                        const messageContent = messageMatch[1].trim()
+                        if (!messageContent.includes('[Heartbeat')) {
+                          if (messageContent.includes('Task failed')) {
+                            console.error('[Claude Code Service] ❌ TASK FAILED (retry):', messageContent)
+                          }
+                          callbacks.onMessage(messageContent)
+                        }
+                      }
+                    }
+                  }
+                } catch (error) {
+                  callbacks.onMessage(data)
+                  lineBuffer = ''
+                }
+              },
+              onStderr: (data: string) => {
+                stderrChunkCount++
+                receivedAnyOutput = true
+                console.log(`[Claude Code Service] ⚠️  stderr (retry):`, data)
+              },
+            }
+          )
+
+          execution = await retryHandle.wait()
+          console.log('[Claude Code Service] ✅ Retry completed', {
+            exitCode: execution?.exitCode,
+            stdoutChunkCount,
+            completionDetected,
+          })
+        } catch (retryError) {
+          executionError = retryError instanceof Error ? retryError : new Error(String(retryError))
+          console.error('[Claude Code Service] ❌ Retry also failed:', executionError.message)
+        }
+      }
+
       // Handle execution failure
       // Note: With spawn() we no longer hit the 120-second timeout issue that run() had
       if (executionError) {

packages/agent/src/executor.ts

@@ -52,6 +52,23 @@ export async function runExecutor(
 
   const messages: SDKMessage[] = []
 
+  // Suppress unhandled rejections from the Claude Agent SDK during session resume.
+  // When resume fails with "No conversation found", the SDK yields an error result
+  // AND throws an unhandled promise rejection from its internal readMessages() function.
+  // This rejection bypasses try/catch and crashes the process before retry logic can run.
+  let suppressedResumeError = false
+  const rejectHandler = (reason: any) => {
+    const msg = reason instanceof Error ? reason.message : String(reason)
+    if (msg.includes('No conversation found') || msg.includes('error result')) {
+      console.warn('Suppressed SDK unhandled rejection during resume:', msg)
+      suppressedResumeError = true
+      return // Suppress — retry logic will handle this
+    }
+    // Re-throw non-resume errors
+    throw reason
+  }
+  process.on('unhandledRejection', rejectHandler)
+
   // Heartbeat to keep connection alive during long operations
   const heartbeatInterval = setInterval(() => {
     console.log('Streaming: [Heartbeat - Agent is working...]')
@@ -171,23 +188,46 @@ export async function runExecutor(
       })) {
         messages.push(message)
 
-        // Stream slimified messages — small JSON that never spans multiple stdout chunks
-        const slimMessages = slimifyMessage(message)
-        for (const slim of slimMessages) {
-          console.log(`Streaming: ${JSON.stringify(slim)}`)
-        }
-
         // Also stream completion status separately for easier detection
         if (message.type === 'result') {
           if (message.subtype === 'success') {
+            // Stream slimified result and status
+            const slimMessages = slimifyMessage(message)
+            for (const slim of slimMessages) {
+              console.log(`Streaming: ${JSON.stringify(slim)}`)
+            }
             console.log(`Streaming: Task completed successfully`)
             console.log(`Streaming: Cost: $${message.total_cost_usd.toFixed(4)}, Duration: ${(message.duration_ms / 1000).toFixed(2)}s`)
           } else {
             const errors = (message as any).errors || []
+            taskFailed = true
+
+            // When resuming, DON'T stream the error result to the frontend — we will
+            // retry with a fresh session. Streaming it would show a confusing "Task Failed"
+            // card before the retry succeeds.
+            if (withResume) {
+              console.warn('Task failed during resume — suppressing error result and breaking to retry')
+              console.warn('Resume failure details:', message.subtype, JSON.stringify(errors))
+              break
+            }
+
+            // Non-resume failure: stream the error to the frontend
+            const slimMessages = slimifyMessage(message)
+            for (const slim of slimMessages) {
+              console.log(`Streaming: ${JSON.stringify(slim)}`)
+            }
             console.log(`Streaming: Task failed: ${message.subtype}`)
             console.log(`Streaming: Task failed errors: ${JSON.stringify(errors)}`)
             console.log(`Streaming: Task failed stop_reason: ${(message as any).stop_reason}`)
-            taskFailed = true
+          }
+        } else {
+          // Stream non-result messages normally (but skip during resume attempts
+          // since they'll just show a brief init before retry)
+          if (!withResume || message.type !== 'system') {
+            const slimMessages = slimifyMessage(message)
+            for (const slim of slimMessages) {
+              console.log(`Streaming: ${JSON.stringify(slim)}`)
+            }
           }
         }
       }
@@ -202,18 +242,22 @@ export async function runExecutor(
         console.log('Streaming: Session resume failed, starting fresh session...')
         messages.length = 0 // Clear any partial messages
         taskFailed = false
+        // Allow any pending SDK microtasks (unhandled rejections) to settle
+        await new Promise(resolve => setTimeout(resolve, 100))
         await runQuery(false)
       } else {
         throw resumeError
       }
     }
 
-    // If task failed with resume, retry without resume
+    // If task failed with resume (broke out of loop), retry without resume
     if (taskFailed && useResume) {
       console.warn('Task failed with resume, retrying without resume...')
       console.log('Streaming: Retrying without session resume...')
       messages.length = 0
       taskFailed = false
+      // Allow any pending SDK microtasks (unhandled rejections) to settle
+      await new Promise(resolve => setTimeout(resolve, 100))
       await runQuery(false)
     }
 
@@ -230,5 +274,6 @@ export async function runExecutor(
     return { success: false, messages, error: errorMessage }
   } finally {
     clearInterval(heartbeatInterval)
+    process.removeListener('unhandledRejection', rejectHandler)
   }
 }

packages/sandbox/templates/shared/executor.mjs

@@ -205,6 +205,17 @@ async function runExecutor(args, config, hooks) {
     console.error("Directory check failed:", err);
   }
   const messages = [];
+  let suppressedResumeError = false;
+  const rejectHandler = (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    if (msg.includes("No conversation found") || msg.includes("error result")) {
+      console.warn("Suppressed SDK unhandled rejection during resume:", msg);
+      suppressedResumeError = true;
+      return;
+    }
+    throw reason;
+  };
+  process.on("unhandledRejection", rejectHandler);
   const heartbeatInterval = setInterval(() => {
     console.log("Streaming: [Heartbeat - Agent is working...]");
   }, cfg.heartbeatInterval);
@@ -290,20 +301,36 @@ ${args.prompt}`;
         options
       })) {
         messages.push(message);
-        const slimMessages = slimifyMessage(message);
-        for (const slim of slimMessages) {
-          console.log(`Streaming: ${JSON.stringify(slim)}`);
-        }
         if (message.type === "result") {
           if (message.subtype === "success") {
+            const slimMessages = slimifyMessage(message);
+            for (const slim of slimMessages) {
+              console.log(`Streaming: ${JSON.stringify(slim)}`);
+            }
             console.log(`Streaming: Task completed successfully`);
             console.log(`Streaming: Cost: $${message.total_cost_usd.toFixed(4)}, Duration: ${(message.duration_ms / 1e3).toFixed(2)}s`);
           } else {
             const errors = message.errors || [];
+            taskFailed = true;
+            if (withResume) {
+              console.warn("Task failed during resume \u2014 suppressing error result and breaking to retry");
+              console.warn("Resume failure details:", message.subtype, JSON.stringify(errors));
+              break;
+            }
+            const slimMessages = slimifyMessage(message);
+            for (const slim of slimMessages) {
+              console.log(`Streaming: ${JSON.stringify(slim)}`);
+            }
             console.log(`Streaming: Task failed: ${message.subtype}`);
             console.log(`Streaming: Task failed errors: ${JSON.stringify(errors)}`);
             console.log(`Streaming: Task failed stop_reason: ${message.stop_reason}`);
-            taskFailed = true;
+          }
+        } else {
+          if (!withResume || message.type !== "system") {
+            const slimMessages = slimifyMessage(message);
+            for (const slim of slimMessages) {
+              console.log(`Streaming: ${JSON.stringify(slim)}`);
+            }
           }
         }
       }
@@ -316,6 +343,7 @@ ${args.prompt}`;
         console.log("Streaming: Session resume failed, starting fresh session...");
         messages.length = 0;
         taskFailed = false;
+        await new Promise((resolve2) => setTimeout(resolve2, 100));
         await runQuery(false);
       } else {
         throw resumeError;
@@ -326,6 +354,7 @@ ${args.prompt}`;
       console.log("Streaming: Retrying without session resume...");
       messages.length = 0;
       taskFailed = false;
+      await new Promise((resolve2) => setTimeout(resolve2, 100));
       await runQuery(false);
     }
     console.log("Query completed successfully");
@@ -339,6 +368,7 @@ ${args.prompt}`;
     return { success: false, messages, error: errorMessage };
   } finally {
     clearInterval(heartbeatInterval);
+    process.removeListener("unhandledRejection", rejectHandler);
   }
 }