Fix resuming existing tasks locally from remote

Author: charlesvien

apps/twig/src/main/services/agent/service.ts

@@ -430,6 +430,11 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
     const mockNodeDir = this.setupMockNodeEnvironment(taskRunId);
     this.setupEnvironment(credentials, mockNodeDir);
 
+    // Abort controller that fires when the agent process exits, used to
+    // race initialize/newSession/extMethod so they fail immediately instead
+    // of hanging forever when the subprocess dies early.
+    const processExitController = new AbortController();
+
     const agent = new Agent({
       posthog: {
         apiUrl: credentials.apiHost,
@@ -458,6 +463,14 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
           },
           onProcessExited: (pid) => {
             this.processTracking.unregister(pid, "agent-exited");
+            log.warn("Agent process exited during session setup", {
+              taskRunId,
+              taskId,
+              pid,
+            });
+            processExitController.abort(
+              new Error("Agent process exited unexpectedly"),
+            );
           },
         },
       });
@@ -469,16 +482,36 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
         clientStreams,
       );
 
-      await connection.initialize({
-        protocolVersion: PROTOCOL_VERSION,
-        clientCapabilities: {
-          fs: {
-            readTextFile: true,
-            writeTextFile: true,
+      // Helper: race a promise against the agent process exiting so we
+      // never hang on a dead subprocess.
+      const raceProcessExit = <T>(promise: Promise<T>): Promise<T> => {
+        if (processExitController.signal.aborted) {
+          return Promise.reject(processExitController.signal.reason);
+        }
+        return Promise.race([
+          promise,
+          new Promise<never>((_, reject) => {
+            processExitController.signal.addEventListener(
+              "abort",
+              () => reject(processExitController.signal.reason),
+              { once: true },
+            );
+          }),
+        ]);
+      };
+
+      await raceProcessExit(
+        connection.initialize({
+          protocolVersion: PROTOCOL_VERSION,
+          clientCapabilities: {
+            fs: {
+              readTextFile: true,
+              writeTextFile: true,
+            },
+            terminal: true,
           },
-          terminal: true,
-        },
-      });
+        }),
+      );
 
       const mcpServers = this.buildMcpServers(credentials);
 
@@ -489,9 +522,8 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
 
       if (isReconnect) {
         const systemPrompt = this.buildPostHogSystemPrompt(credentials);
-        const resumeResponse = await connection.extMethod(
-          "_posthog/session/resume",
-          {
+        const resumeResponse = await raceProcessExit(
+          connection.extMethod("_posthog/session/resume", {
             sessionId: taskRunId,
             cwd: repoPath,
             mcpServers,
@@ -507,7 +539,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
                 },
               }),
             },
-          },
+          }),
         );
         const resumeMeta = resumeResponse?._meta as
           | {
@@ -521,21 +553,23 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
         currentModelId = resumeMeta?.models?.currentModelId;
       } else {
         const systemPrompt = this.buildPostHogSystemPrompt(credentials);
-        const newSessionResponse = await connection.newSession({
-          cwd: repoPath,
-          mcpServers,
-          _meta: {
-            sessionId: taskRunId,
-            model,
-            systemPrompt,
-            ...(executionMode && { initialModeId: executionMode }),
-            ...(additionalDirectories?.length && {
-              claudeCode: {
-                options: { additionalDirectories },
-              },
-            }),
-          },
-        });
+        const newSessionResponse = await raceProcessExit(
+          connection.newSession({
+            cwd: repoPath,
+            mcpServers,
+            _meta: {
+              sessionId: taskRunId,
+              model,
+              systemPrompt,
+              ...(executionMode && { initialModeId: executionMode }),
+              ...(additionalDirectories?.length && {
+                claudeCode: {
+                  options: { additionalDirectories },
+                },
+              }),
+            },
+          }),
+        );
         availableModels = newSessionResponse.models?.availableModels;
         currentModelId = newSessionResponse.models?.currentModelId;
       }

apps/twig/src/renderer/features/sessions/stores/sessionStore.ts

@@ -737,25 +737,29 @@ const useStore = create<SessionStore>()(
             }
           }
         } else {
-          unsubscribeFromChannel(taskRunId);
-          updateSession(taskRunId, {
-            status: "error",
-            errorMessage:
-              "Failed to reconnect to the agent. Please restart the task.",
+          // Reconnect returned null — agent process likely exited because the
+          // local Claude Code session no longer exists on disk.
+          // Fall back to starting a fresh session.
+          log.warn("Reconnect returned null, falling back to new session", {
+            taskId,
+            taskRunId,
           });
+          unsubscribeFromChannel(taskRunId);
+          removeSession(taskRunId);
+          await createNewLocalSession(taskId, taskTitle, repoPath, auth);
         }
       } catch (error) {
-        // Handle reconnection errors - session already added, just update status
-        unsubscribeFromChannel(taskRunId);
+        // Reconnect failed (e.g. agent process exited unexpectedly).
+        // Fall back to starting a fresh session.
         const errorMessage =
           error instanceof Error ? error.message : String(error);
-        log.error("Failed to reconnect to session", { taskId, error });
-        updateSession(taskRunId, {
-          status: "error",
-          errorMessage:
-            errorMessage ||
-            "Failed to reconnect to the agent. Please try again.",
+        log.warn("Reconnect failed, falling back to new session", {
+          taskId,
+          error: errorMessage,
         });
+        unsubscribeFromChannel(taskRunId);
+        removeSession(taskRunId);
+        await createNewLocalSession(taskId, taskTitle, repoPath, auth);
       }
     };
 

apps/twig/src/renderer/features/task-detail/components/TaskLogsPanel.tsx

@@ -8,14 +8,17 @@ import {
 } from "@features/sessions/stores/sessionStore";
 import { useCwd } from "@features/sidebar/hooks/useCwd";
 import { useTaskViewedStore } from "@features/sidebar/stores/taskViewedStore";
+import { WorkspaceSetupPrompt } from "@features/task-detail/components/WorkspaceSetupPrompt";
 import { useDeleteTask } from "@features/tasks/hooks/useTasks";
 import { useWorkspaceStore } from "@features/workspace/stores/workspaceStore";
 import { useConnectivity } from "@hooks/useConnectivity";
 import { Box } from "@radix-ui/themes";
 import { logger } from "@renderer/lib/logger";
 import { useNavigationStore } from "@renderer/stores/navigationStore";
+import { useTaskDirectoryStore } from "@renderer/stores/taskDirectoryStore";
 import { trpcVanilla } from "@renderer/trpc/client";
 import type { Task } from "@shared/types";
+import { getTaskRepository } from "@utils/repository";
 import { toast } from "@utils/toast";
 import { useCallback, useEffect, useRef } from "react";
 
@@ -29,6 +32,12 @@ interface TaskLogsPanelProps {
 export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
   const repoPath = useCwd(taskId);
   const workspace = useWorkspaceStore((s) => s.workspaces[taskId]);
+  const isWorkspaceLoaded = useWorkspaceStore((s) => s.isLoaded);
+  const isCreatingWorkspace = useWorkspaceStore((s) => !!s.isCreating[taskId]);
+  const repoKey = getTaskRepository(task);
+  const hasDirectoryMapping = useTaskDirectoryStore(
+    (s) => !!repoKey && repoKey in s.repoDirectories,
+  );
 
   const session = useSessionForTask(taskId);
   const {
@@ -187,6 +196,21 @@ export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
     [taskId, repoPath, appendUserShellExecute],
   );
 
+  if (
+    !repoPath &&
+    isWorkspaceLoaded &&
+    !hasDirectoryMapping &&
+    !isCreatingWorkspace
+  ) {
+    return (
+      <BackgroundWrapper>
+        <Box height="100%" width="100%">
+          <WorkspaceSetupPrompt taskId={taskId} task={task} />
+        </Box>
+      </BackgroundWrapper>
+    );
+  }
+
   return (
     <BackgroundWrapper>
       <Box height="100%" width="100%">

apps/twig/src/renderer/features/task-detail/components/WorkspaceSetupPrompt.tsx

@@ -0,0 +1,93 @@
+import { FolderPicker } from "@features/folder-picker/components/FolderPicker";
+import { useTaskExecutionStore } from "@features/task-detail/stores/taskExecutionStore";
+import { useWorkspaceStore } from "@features/workspace/stores/workspaceStore";
+import { Folder } from "@phosphor-icons/react";
+import { Box, Code, Flex, Spinner, Text } from "@radix-ui/themes";
+import { logger } from "@renderer/lib/logger";
+import { useRegisteredFoldersStore } from "@renderer/stores/registeredFoldersStore";
+import { useTaskDirectoryStore } from "@renderer/stores/taskDirectoryStore";
+import type { Task } from "@shared/types";
+import { getTaskRepository } from "@utils/repository";
+import { useCallback, useState } from "react";
+
+const log = logger.scope("workspace-setup-prompt");
+
+interface WorkspaceSetupPromptProps {
+  taskId: string;
+  task: Task;
+}
+
+export function WorkspaceSetupPrompt({
+  taskId,
+  task,
+}: WorkspaceSetupPromptProps) {
+  const [isSettingUp, setIsSettingUp] = useState(false);
+  const [selectedPath, setSelectedPath] = useState("");
+  const repository = getTaskRepository(task);
+
+  const handleFolderSelect = useCallback(
+    async (path: string) => {
+      setSelectedPath(path);
+      setIsSettingUp(true);
+
+      try {
+        const addFolder = useRegisteredFoldersStore.getState().addFolder;
+        await addFolder(path);
+
+        if (repository) {
+          useTaskDirectoryStore.getState().setRepoDirectory(repository, path);
+        }
+
+        await useWorkspaceStore
+          .getState()
+          .ensureWorkspace(taskId, path, "worktree");
+        useTaskExecutionStore.getState().setRepoPath(taskId, path);
+
+        log.info("Workspace setup complete", { taskId, path });
+      } catch (error) {
+        log.error("Failed to set up workspace", error);
+        setIsSettingUp(false);
+      }
+    },
+    [taskId, repository],
+  );
+
+  return (
+    <Flex
+      align="center"
+      justify="center"
+      direction="column"
+      gap="3"
+      className="absolute inset-0"
+    >
+      {isSettingUp ? (
+        <>
+          <Spinner size="3" />
+          <Text size="2" className="text-gray-11">
+            Setting up workspace...
+          </Text>
+        </>
+      ) : (
+        <>
+          <Folder size={32} weight="duotone" className="text-gray-9" />
+          <Text size="3" weight="medium" className="text-gray-12">
+            Select a repository folder
+          </Text>
+          {repository && (
+            <Text size="2" className="text-gray-11">
+              This task is linked to <Code>{repository}</Code>
+            </Text>
+          )}
+          <Box mt="1">
+            <FolderPicker
+              value={selectedPath}
+              onChange={handleFolderSelect}
+              placeholder="Select folder..."
+              size="2"
+            />
+          </Box>
+        </>
+      )}
+    </Flex>
+  );
+}