feat: add directory prompt on run and cloud mode gating

When clicking "Run (Local)" without a directory set:
- Tasks WITH repository_config: Prompt "Do you have it locally?"
  → "I have it locally" opens folder picker
  → "Clone for me" triggers clone flow with progress UI
- Tasks WITHOUT repository_config: Prompt "Select working directory"
  → Opens folder picker

Cloud mode changes:
- Disable Cloud mode toggle for tasks without repository_config
- Show tooltip: "Cloud mode requires a connected repository"

Technical changes:
- Updated runTask() in taskExecutionStore to prompt before showing error
- Integrated with existing clone flow and progress UI (PR #128)
- Persist selected directories via taskDirectoryStore (PR #130, #131)
- Removed noisy directory source badges (simplified UX)

This creates a frictionless flow where engineers can easily point to
existing repos or clone them on-demand, while still supporting
directory-only tasks for non-git workflows.

Author: lucasheriques

src/renderer/features/task-detail/components/TaskActions.tsx

@@ -7,6 +7,7 @@ interface TaskActionsProps {
   isCloningRepo: boolean;
   cloneProgress: { message: string; percent: number } | null;
   runMode: "local" | "cloud";
+  hasRepositoryConfig: boolean;
   onRunTask: () => void;
   onCancel: () => void;
   onRunModeChange: (mode: "local" | "cloud") => void;
@@ -17,6 +18,7 @@ export const TaskActions: React.FC<TaskActionsProps> = ({
   isCloningRepo,
   cloneProgress,
   runMode,
+  hasRepositoryConfig,
   onRunTask,
   onCancel,
   onRunModeChange,
@@ -58,12 +60,18 @@ export const TaskActions: React.FC<TaskActionsProps> = ({
           >
             <span className="truncate">{getRunButtonLabel()}</span>
           </Button>
-          <Tooltip content="Toggle between Local or Cloud Agent">
+          <Tooltip
+            content={
+              !hasRepositoryConfig
+                ? "Cloud mode requires a connected repository"
+                : "Toggle between Local or Cloud Agent"
+            }
+          >
             <IconButton
               size="2"
               variant="classic"
               color={runMode === "cloud" ? "blue" : "gray"}
-              disabled={isRunning || isCloningRepo}
+              disabled={isRunning || isCloningRepo || !hasRepositoryConfig}
               onClick={() =>
                 onRunModeChange(runMode === "local" ? "cloud" : "local")
               }

src/renderer/features/task-detail/components/TaskDetailPanel.tsx

@@ -101,6 +101,7 @@ export function TaskDetailPanel({ taskId, task }: TaskDetailPanelProps) {
             isCloningRepo={repository.isCloning}
             cloneProgress={taskData.cloneProgress}
             runMode={execution.state.runMode}
+            hasRepositoryConfig={!!taskData.task.repository_config}
             onRunTask={execution.actions.run}
             onCancel={execution.actions.cancel}
             onRunModeChange={execution.actions.onRunModeChange}

src/renderer/features/task-detail/components/TaskMetadata.tsx

@@ -1,9 +1,9 @@
+import { FolderPicker } from "@features/folder-picker/components/FolderPicker";
+import { useTaskExecutionStore } from "@features/task-detail/stores/taskExecutionStore";
 import { Button, Code, DataList, Link, Text, Tooltip } from "@radix-ui/themes";
 import type { Task } from "@shared/types";
 import { format, formatDistanceToNow } from "date-fns";
 import type React from "react";
-import { FolderPicker } from "@features/folder-picker/components/FolderPicker";
-import { useTaskExecutionStore } from "@features/task-detail/stores/taskExecutionStore";
 
 interface TaskMetadataProps {
   task: Task;

src/renderer/features/task-detail/stores/taskExecutionStore.ts

@@ -461,11 +461,100 @@ export const useTaskExecutionStore = create<TaskExecutionStore>()(
         const effectiveRepoPath = taskState.repoPath;
 
         if (!effectiveRepoPath) {
-          store.addLog(taskId, {
-            type: "error",
-            ts: Date.now(),
-            message: "No repository folder selected.",
+          // Prompt user to select directory or clone
+          const hasRepo = !!task.repository_config;
+          const repoConfig = task.repository_config;
+
+          const result = await window.electronAPI.showMessageBox({
+            type: "question",
+            title: "Select working directory",
+            message:
+              hasRepo && repoConfig
+                ? `Do you have ${repoConfig.organization}/${repoConfig.repository} locally?`
+                : "Select a working directory for this task",
+            detail: hasRepo
+              ? "If you have the repository locally, we'll use that. Otherwise, we can clone it for you."
+              : "Choose a directory where the task will run.",
+            buttons: hasRepo
+              ? ["I have it locally", "Clone for me", "Cancel"]
+              : ["Select directory", "Cancel"],
+            defaultId: 0,
+            cancelId: hasRepo ? 2 : 1,
           });
+
+          if (result.response === (hasRepo ? 2 : 1)) {
+            // User cancelled
+            return;
+          }
+
+          if (result.response === 0) {
+            // User has repo locally or wants to select directory
+            const selectedPath = await window.electronAPI.selectDirectory();
+
+            if (!selectedPath) {
+              // User cancelled directory selection
+              return;
+            }
+
+            // Set the repo path and revalidate
+            store.setRepoPath(taskId, selectedPath);
+            await store.revalidateRepo(taskId);
+
+            // Retry running the task with the new path
+            return store.runTask(taskId, task);
+          }
+
+          if (result.response === 1 && hasRepo && repoConfig) {
+            // User wants to clone - trigger clone and retry
+            const { repositoryWorkspaceStore } = await import(
+              "@stores/repositoryWorkspaceStore"
+            );
+
+            // Derive default path from workspace
+            const { defaultWorkspace } = useAuthStore.getState();
+            if (!defaultWorkspace) {
+              store.addLog(taskId, {
+                type: "error",
+                ts: Date.now(),
+                message:
+                  "No workspace configured. Please configure a workspace in settings.",
+              });
+              return;
+            }
+
+            const derivedPath = derivePath(
+              defaultWorkspace,
+              repoConfig.repository,
+            );
+            store.setRepoPath(taskId, derivedPath);
+
+            const cloneId = `clone-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+            cloneStore.getState().startClone(cloneId, repoConfig, derivedPath);
+
+            try {
+              await repositoryWorkspaceStore
+                .getState()
+                .selectRepository(repoConfig, cloneId);
+
+              // Wait for clone to complete, then retry run
+              // The clone progress will show in the UI via TaskActions
+              // We return here and let the user manually retry after clone completes
+              store.addLog(taskId, {
+                type: "token",
+                ts: Date.now(),
+                content: `Cloning ${repoConfig.organization}/${repoConfig.repository}... Click Run again after the clone completes.`,
+              });
+              return;
+            } catch (error) {
+              store.addLog(taskId, {
+                type: "error",
+                ts: Date.now(),
+                message: `Failed to clone repository: ${error instanceof Error ? error.message : "Unknown error"}`,
+              });
+              return;
+            }
+          }
+
           return;
         }