feat: enhance UI components and branch management

- Added new RadioGroup and Switch components for better UI interaction. - Introduced BranchSelector for improved branch selection in feature dialogs. - Updated Autocomplete and BranchAutocomplete components to handle error states. - Refactored feature management to archive verified features instead of deleting them. - Enhanced worktree handling by removing worktreePath from features, relying on branchName instead. - Improved auto mode functionality by integrating branch management and worktree updates. - Cleaned up unused code and optimized existing logic for better performance.
2026-01-31 20:03:37 +00:00 · 2025-12-17 22:29:39 -05:00
parent cffdec91f1
commit 0549b8085a
45 changed files with 1669 additions and 1346 deletions
--- a/apps/app/src/components/ui/autocomplete.tsx
+++ b/apps/app/src/components/ui/autocomplete.tsx
@@ -35,6 +35,7 @@ interface AutocompleteProps {
  emptyMessage?: string;
  className?: string;
  disabled?: boolean;
+  error?: boolean;
  icon?: LucideIcon;
  allowCreate?: boolean;
  createLabel?: (value: string) => string;
@@ -58,6 +59,7 @@ export function Autocomplete({
  emptyMessage = "No results found.",
  className,
  disabled = false,
+  error = false,
  icon: Icon,
  allowCreate = false,
  createLabel = (v) => `Create "${v}"`,
@@ -130,6 +132,7 @@ export function Autocomplete({
          className={cn(
            "w-full justify-between",
            Icon && "font-mono text-sm",
+            error && "border-destructive focus-visible:ring-destructive",
            className
          )}
          data-testid={testId}
--- a/apps/app/src/components/ui/branch-autocomplete.tsx
+++ b/apps/app/src/components/ui/branch-autocomplete.tsx
@@ -11,6 +11,7 @@ interface BranchAutocompleteProps {
  placeholder?: string;
  className?: string;
  disabled?: boolean;
+  error?: boolean;
  "data-testid"?: string;
 }

@@ -21,6 +22,7 @@ export function BranchAutocomplete({
  placeholder = "Select a branch...",
  className,
  disabled = false,
+  error = false,
  "data-testid": testId,
 }: BranchAutocompleteProps) {
  // Always include "main" at the top of suggestions
@@ -43,6 +45,7 @@ export function BranchAutocomplete({
      emptyMessage="No branches found."
      className={className}
      disabled={disabled}
+      error={error}
      icon={GitBranch}
      allowCreate
      createLabel={(v) => `Create "${v}"`}
--- a/apps/app/src/components/ui/radio-group.tsx
+++ b/apps/app/src/components/ui/radio-group.tsx
@@ -0,0 +1,45 @@
+"use client";
+
+import * as React from "react";
+import * as RadioGroupPrimitive from "@radix-ui/react-radio-group";
+import { Circle } from "lucide-react";
+
+import { cn } from "@/lib/utils";
+
+const RadioGroup = React.forwardRef<
+  React.ElementRef<typeof RadioGroupPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root>
+>(({ className, ...props }, ref) => {
+  return (
+    <RadioGroupPrimitive.Root
+      className={cn("grid gap-2", className)}
+      {...props}
+      ref={ref}
+    />
+  );
+});
+RadioGroup.displayName = RadioGroupPrimitive.Root.displayName;
+
+const RadioGroupItem = React.forwardRef<
+  React.ElementRef<typeof RadioGroupPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item>
+>(({ className, ...props }, ref) => {
+  return (
+    <RadioGroupPrimitive.Item
+      ref={ref}
+      className={cn(
+        "aspect-square h-4 w-4 rounded-full border border-primary text-primary ring-offset-background focus:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:cursor-not-allowed disabled:opacity-50",
+        className
+      )}
+      {...props}
+    >
+      <RadioGroupPrimitive.Indicator className="flex items-center justify-center">
+        <Circle className="h-2.5 w-2.5 fill-current text-current" />
+      </RadioGroupPrimitive.Indicator>
+    </RadioGroupPrimitive.Item>
+  );
+});
+RadioGroupItem.displayName = RadioGroupPrimitive.Item.displayName;
+
+export { RadioGroup, RadioGroupItem };
+
--- a/apps/app/src/components/ui/switch.tsx
+++ b/apps/app/src/components/ui/switch.tsx
@@ -0,0 +1,30 @@
+"use client";
+
+import * as React from "react";
+import * as SwitchPrimitives from "@radix-ui/react-switch";
+
+import { cn } from "@/lib/utils";
+
+const Switch = React.forwardRef<
+  React.ElementRef<typeof SwitchPrimitives.Root>,
+  React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root>
+>(({ className, ...props }, ref) => (
+  <SwitchPrimitives.Root
+    className={cn(
+      "peer inline-flex h-6 w-11 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input",
+      className
+    )}
+    {...props}
+    ref={ref}
+  >
+    <SwitchPrimitives.Thumb
+      className={cn(
+        "pointer-events-none block h-5 w-5 rounded-full bg-background shadow-lg ring-0 transition-transform data-[state=checked]:translate-x-5 data-[state=unchecked]:translate-x-0"
+      )}
+    />
+  </SwitchPrimitives.Root>
+));
+Switch.displayName = SwitchPrimitives.Root.displayName;
+
+export { Switch };
+
--- a/apps/app/src/components/views/board-view.tsx
+++ b/apps/app/src/components/views/board-view.tsx
@@ -1,6 +1,6 @@
 "use client";

-import { useEffect, useState, useCallback, useMemo } from "react";
+import { useEffect, useState, useCallback, useMemo, useRef } from "react";
 import {
  PointerSensor,
  useSensor,
@@ -10,7 +10,9 @@ import {
 } from "@dnd-kit/core";
 import { useAppStore, Feature } from "@/store/app-store";
 import { getElectronAPI } from "@/lib/electron";
+import type { AutoModeEvent } from "@/types/electron";
 import { pathsEqual } from "@/lib/utils";
+import { getBlockingDependencies } from "@/lib/dependency-resolver";
 import { BoardBackgroundModal } from "@/components/dialogs/board-background-modal";
 import { RefreshCw } from "lucide-react";
 import { useAutoMode } from "@/hooks/use-auto-mode";
@@ -25,7 +27,7 @@ import {
  AddFeatureDialog,
  AgentOutputModal,
  CompletedFeaturesModal,
-  DeleteAllVerifiedDialog,
+  ArchiveAllVerifiedDialog,
  DeleteCompletedFeatureDialog,
  EditFeatureDialog,
  FeatureSuggestionsDialog,
@@ -72,6 +74,10 @@ export function BoardView() {
    setCurrentWorktree,
    getWorktrees,
    setWorktrees,
+    useWorktrees,
+    enableDependencyBlocking,
+    isPrimaryWorktreeBranch,
+    getPrimaryWorktreeBranch,
  } = useAppStore();
  const shortcuts = useKeyboardShortcutsConfig();
  const {
@@ -89,7 +95,7 @@ export function BoardView() {
  const [featuresWithContext, setFeaturesWithContext] = useState<Set<string>>(
    new Set()
  );
-  const [showDeleteAllVerifiedDialog, setShowDeleteAllVerifiedDialog] =
+  const [showArchiveAllVerifiedDialog, setShowArchiveAllVerifiedDialog] =
    useState(false);
  const [showBoardBackgroundModal, setShowBoardBackgroundModal] =
    useState(false);
@@ -277,6 +283,27 @@ export function BoardView() {
  const { persistFeatureCreate, persistFeatureUpdate, persistFeatureDelete } =
    useBoardPersistence({ currentProject });

+  // Memoize the removed worktrees handler to prevent infinite loops
+  const handleRemovedWorktrees = useCallback(
+    (removedWorktrees: Array<{ path: string; branch: string }>) => {
+      // Reset features that were assigned to the removed worktrees (by branch)
+      hookFeatures.forEach((feature) => {
+        const matchesRemovedWorktree = removedWorktrees.some((removed) => {
+          // Match by branch name since worktreePath is no longer stored
+          return feature.branchName === removed.branch;
+        });
+
+        if (matchesRemovedWorktree) {
+          // Reset the feature's branch assignment
+          persistFeatureUpdate(feature.id, {
+            branchName: null as unknown as string | undefined,
+          });
+        }
+      });
+    },
+    [hookFeatures, persistFeatureUpdate]
+  );
+
  // Get in-progress features for keyboard shortcuts (needed before actions hook)
  const inProgressFeaturesForShortcuts = useMemo(() => {
    return hookFeatures.filter((f) => {
@@ -285,13 +312,12 @@ export function BoardView() {
    });
  }, [hookFeatures, runningAutoTasks]);

-  // Get current worktree info (path and branch) for filtering features
+  // Get current worktree info (path) for filtering features
  // This needs to be before useBoardActions so we can pass currentWorktreeBranch
  const currentWorktreeInfo = currentProject
    ? getCurrentWorktree(currentProject.path)
    : null;
  const currentWorktreePath = currentWorktreeInfo?.path ?? null;
-  const currentWorktreeBranch = currentWorktreeInfo?.branch ?? null;
  const worktreesByProject = useAppStore((s) => s.worktreesByProject);
  const worktrees = useMemo(
    () =>
@@ -301,8 +327,25 @@ export function BoardView() {
    [currentProject, worktreesByProject]
  );

+  // Get the branch for the currently selected worktree
+  // Find the worktree that matches the current selection, or use main worktree
+  const selectedWorktree = useMemo(() => {
+    if (currentWorktreePath === null) {
+      // Primary worktree selected - find the main worktree
+      return worktrees.find((w) => w.isMain);
+    } else {
+      // Specific worktree selected - find it by path
+      return worktrees.find(
+        (w) => !w.isMain && pathsEqual(w.path, currentWorktreePath)
+      );
+    }
+  }, [worktrees, currentWorktreePath]);
+
+  // Get the current branch from the selected worktree (not from store which may be stale)
+  const currentWorktreeBranch = selectedWorktree?.branch ?? null;
+
  // Get the branch for the currently selected worktree (for defaulting new features)
-  // Use the branch from currentWorktreeInfo, or fall back to main worktree's branch
+  // Use the branch from selectedWorktree, or fall back to main worktree's branch
  const selectedWorktreeBranch =
    currentWorktreeBranch || worktrees.find((w) => w.isMain)?.branch || "main";

@@ -326,7 +369,7 @@ export function BoardView() {
    handleOutputModalNumberKeyPress,
    handleForceStopFeature,
    handleStartNextFeatures,
-    handleDeleteAllVerified,
+    handleArchiveAllVerified,
  } = useBoardActions({
    currentProject,
    features: hookFeatures,
@@ -354,6 +397,202 @@ export function BoardView() {
    currentWorktreeBranch,
  });

+  // Client-side auto mode: periodically check for backlog items and move them to in-progress
+  // Use a ref to track the latest auto mode state so async operations always check the current value
+  const autoModeRunningRef = useRef(autoMode.isRunning);
+  useEffect(() => {
+    autoModeRunningRef.current = autoMode.isRunning;
+  }, [autoMode.isRunning]);
+
+  // Track features that are pending (started but not yet confirmed running)
+  const pendingFeaturesRef = useRef<Set<string>>(new Set());
+
+  // Listen to auto mode events to remove features from pending when they start running
+  useEffect(() => {
+    const api = getElectronAPI();
+    if (!api?.autoMode) return;
+
+    const unsubscribe = api.autoMode.onEvent((event: AutoModeEvent) => {
+      if (!currentProject) return;
+
+      // Only process events for the current project
+      const eventProjectPath =
+        "projectPath" in event ? event.projectPath : undefined;
+      if (eventProjectPath && eventProjectPath !== currentProject.path) {
+        return;
+      }
+
+      switch (event.type) {
+        case "auto_mode_feature_start":
+          // Feature is now confirmed running - remove from pending
+          if (event.featureId) {
+            pendingFeaturesRef.current.delete(event.featureId);
+          }
+          break;
+
+        case "auto_mode_feature_complete":
+        case "auto_mode_error":
+          // Feature completed or errored - remove from pending if still there
+          if (event.featureId) {
+            pendingFeaturesRef.current.delete(event.featureId);
+          }
+          break;
+      }
+    });
+
+    return unsubscribe;
+  }, [currentProject]);
+
+  useEffect(() => {
+    if (!autoMode.isRunning || !currentProject) {
+      return;
+    }
+
+    let isChecking = false;
+    let isActive = true; // Track if this effect is still active
+
+    const checkAndStartFeatures = async () => {
+      // Check if auto mode is still running and effect is still active
+      // Use ref to get the latest value, not the closure value
+      if (!isActive || !autoModeRunningRef.current || !currentProject) {
+        return;
+      }
+
+      // Prevent concurrent executions
+      if (isChecking) {
+        return;
+      }
+
+      isChecking = true;
+      try {
+        // Double-check auto mode is still running before proceeding
+        if (!isActive || !autoModeRunningRef.current || !currentProject) {
+          return;
+        }
+
+        // Count currently running tasks + pending features
+        const currentRunning =
+          runningAutoTasks.length + pendingFeaturesRef.current.size;
+        const availableSlots = maxConcurrency - currentRunning;
+
+        // No available slots, skip check
+        if (availableSlots <= 0) {
+          return;
+        }
+
+        // Filter backlog features by the currently selected worktree branch
+        const primaryBranch = currentProject.path
+          ? getPrimaryWorktreeBranch(currentProject.path)
+          : null;
+        const backlogFeatures = hookFeatures.filter((f) => {
+          if (f.status !== "backlog") return false;
+
+          // Determine the feature's branch (default to primary branch if not set)
+          const featureBranch = f.branchName || primaryBranch || "main";
+
+          // If no worktree is selected (currentWorktreeBranch is null or matches primary),
+          // show features with no branch or primary branch
+          if (
+            !currentWorktreeBranch ||
+            (currentProject.path &&
+              isPrimaryWorktreeBranch(
+                currentProject.path,
+                currentWorktreeBranch
+              ))
+          ) {
+            return (
+              !f.branchName ||
+              (currentProject.path &&
+                isPrimaryWorktreeBranch(currentProject.path, featureBranch))
+            );
+          }
+
+          // Otherwise, only show features matching the selected worktree branch
+          return featureBranch === currentWorktreeBranch;
+        });
+
+        if (backlogFeatures.length === 0) {
+          return;
+        }
+
+        // Sort by priority (lower number = higher priority, priority 1 is highest)
+        const sortedBacklog = [...backlogFeatures].sort(
+          (a, b) => (a.priority || 999) - (b.priority || 999)
+        );
+
+        // Filter out features with blocking dependencies if dependency blocking is enabled
+        const eligibleFeatures = enableDependencyBlocking
+          ? sortedBacklog.filter((f) => {
+              const blockingDeps = getBlockingDependencies(f, hookFeatures);
+              return blockingDeps.length === 0;
+            })
+          : sortedBacklog;
+
+        // Start features up to available slots
+        const featuresToStart = eligibleFeatures.slice(0, availableSlots);
+
+        for (const feature of featuresToStart) {
+          // Check again before starting each feature
+          if (!isActive || !autoModeRunningRef.current || !currentProject) {
+            return;
+          }
+
+          // Simplified: No worktree creation on client - server derives workDir from feature.branchName
+          // If feature has no branchName and primary worktree is selected, assign primary branch
+          if (currentWorktreePath === null && !feature.branchName) {
+            const primaryBranch =
+              (currentProject.path
+                ? getPrimaryWorktreeBranch(currentProject.path)
+                : null) || "main";
+            await persistFeatureUpdate(feature.id, {
+              branchName: primaryBranch,
+            });
+          }
+
+          // Final check before starting implementation
+          if (!isActive || !autoModeRunningRef.current || !currentProject) {
+            return;
+          }
+
+          // Start the implementation - server will derive workDir from feature.branchName
+          const started = await handleStartImplementation(feature);
+
+          // If successfully started, track it as pending until we receive the start event
+          if (started) {
+            pendingFeaturesRef.current.add(feature.id);
+          }
+        }
+      } finally {
+        isChecking = false;
+      }
+    };
+
+    // Check immediately, then every 3 seconds
+    checkAndStartFeatures();
+    const interval = setInterval(checkAndStartFeatures, 3000);
+
+    return () => {
+      // Mark as inactive to prevent any pending async operations from continuing
+      isActive = false;
+      clearInterval(interval);
+      // Clear pending features when effect unmounts or dependencies change
+      pendingFeaturesRef.current.clear();
+    };
+  }, [
+    autoMode.isRunning,
+    currentProject,
+    runningAutoTasks,
+    maxConcurrency,
+    hookFeatures,
+    currentWorktreeBranch,
+    currentWorktreePath,
+    getPrimaryWorktreeBranch,
+    isPrimaryWorktreeBranch,
+    enableDependencyBlocking,
+    persistFeatureUpdate,
+    handleStartImplementation,
+  ]);
+
  // Use keyboard shortcuts hook (after actions hook)
  useBoardKeyboardShortcuts({
    features: hookFeatures,
@@ -422,8 +661,13 @@ export function BoardView() {
        maxConcurrency={maxConcurrency}
        onConcurrencyChange={setMaxConcurrency}
        isAutoModeRunning={autoMode.isRunning}
-        onStartAutoMode={() => autoMode.start()}
-        onStopAutoMode={() => autoMode.stop()}
+        onAutoModeToggle={(enabled) => {
+          if (enabled) {
+            autoMode.start();
+          } else {
+            autoMode.stop();
+          }
+        }}
        onAddFeature={() => setShowAddDialog(true)}
        addFeatureShortcut={{
          key: shortcuts.addFeature,
@@ -454,10 +698,10 @@ export function BoardView() {
          setSelectedWorktreeForAction(worktree);
          setShowCreateBranchDialog(true);
        }}
+        onRemovedWorktrees={handleRemovedWorktrees}
        runningFeatureIds={runningAutoTasks}
        features={hookFeatures.map((f) => ({
          id: f.id,
-          worktreePath: f.worktreePath,
          branchName: f.branchName,
        }))}
      />
@@ -512,7 +756,7 @@ export function BoardView() {
          onStartNextFeatures={handleStartNextFeatures}
          onShowSuggestions={() => setShowSuggestionsDialog(true)}
          suggestionsCount={suggestionsCount}
-          onDeleteAllVerified={() => setShowDeleteAllVerifiedDialog(true)}
+          onArchiveAllVerified={() => setShowArchiveAllVerifiedDialog(true)}
        />
      </div>

@@ -552,6 +796,7 @@ export function BoardView() {
        branchSuggestions={branchSuggestions}
        defaultSkipTests={defaultSkipTests}
        defaultBranch={selectedWorktreeBranch}
+        currentBranch={currentWorktreeBranch || undefined}
        isMaximized={isMaximized}
        showProfilesOnly={showProfilesOnly}
        aiProfiles={aiProfiles}
@@ -564,6 +809,7 @@ export function BoardView() {
        onUpdate={handleUpdateFeature}
        categorySuggestions={categorySuggestions}
        branchSuggestions={branchSuggestions}
+        currentBranch={currentWorktreeBranch || undefined}
        isMaximized={isMaximized}
        showProfilesOnly={showProfilesOnly}
        aiProfiles={aiProfiles}
@@ -580,14 +826,14 @@ export function BoardView() {
        onNumberKeyPress={handleOutputModalNumberKeyPress}
      />

-      {/* Delete All Verified Dialog */}
-      <DeleteAllVerifiedDialog
-        open={showDeleteAllVerifiedDialog}
-        onOpenChange={setShowDeleteAllVerifiedDialog}
+      {/* Archive All Verified Dialog */}
+      <ArchiveAllVerifiedDialog
+        open={showArchiveAllVerifiedDialog}
+        onOpenChange={setShowArchiveAllVerifiedDialog}
        verifiedCount={getColumnFeatures("verified").length}
        onConfirm={async () => {
-          await handleDeleteAllVerified();
-          setShowDeleteAllVerifiedDialog(false);
+          await handleArchiveAllVerified();
+          setShowArchiveAllVerifiedDialog(false);
        }}
      />

@@ -657,19 +903,13 @@ export function BoardView() {
        projectPath={currentProject.path}
        worktree={selectedWorktreeForAction}
        onDeleted={(deletedWorktree, _deletedBranch) => {
-          // Reset features that were assigned to the deleted worktree
+          // Reset features that were assigned to the deleted worktree (by branch)
          hookFeatures.forEach((feature) => {
-            const matchesByPath =
-              feature.worktreePath &&
-              pathsEqual(feature.worktreePath, deletedWorktree.path);
-            const matchesByBranch =
-              feature.branchName === deletedWorktree.branch;
-
-            if (matchesByPath || matchesByBranch) {
-              // Reset the feature's worktree assignment
+            // Match by branch name since worktreePath is no longer stored
+            if (feature.branchName === deletedWorktree.branch) {
+              // Reset the feature's branch assignment
              persistFeatureUpdate(feature.id, {
                branchName: null as unknown as string | undefined,
-                worktreePath: null as unknown as string | undefined,
              });
            }
          });
--- a/apps/app/src/components/views/board-view/board-header.tsx
+++ b/apps/app/src/components/views/board-view/board-header.tsx
@@ -3,7 +3,9 @@
 import { Button } from "@/components/ui/button";
 import { HotkeyButton } from "@/components/ui/hotkey-button";
 import { Slider } from "@/components/ui/slider";
-import { Play, StopCircle, Plus, Users } from "lucide-react";
+import { Switch } from "@/components/ui/switch";
+import { Label } from "@/components/ui/label";
+import { Plus, Users } from "lucide-react";
 import { KeyboardShortcut } from "@/hooks/use-keyboard-shortcuts";

 interface BoardHeaderProps {
@@ -11,8 +13,7 @@ interface BoardHeaderProps {
  maxConcurrency: number;
  onConcurrencyChange: (value: number) => void;
  isAutoModeRunning: boolean;
-  onStartAutoMode: () => void;
-  onStopAutoMode: () => void;
+  onAutoModeToggle: (enabled: boolean) => void;
  onAddFeature: () => void;
  addFeatureShortcut: KeyboardShortcut;
  isMounted: boolean;
@@ -23,8 +24,7 @@ export function BoardHeader({
  maxConcurrency,
  onConcurrencyChange,
  isAutoModeRunning,
-  onStartAutoMode,
-  onStopAutoMode,
+  onAutoModeToggle,
  onAddFeature,
  addFeatureShortcut,
  isMounted,
@@ -63,29 +63,20 @@ export function BoardHeader({

        {/* Auto Mode Toggle - only show after mount to prevent hydration issues */}
        {isMounted && (
-          <>
-            {isAutoModeRunning ? (
-              <Button
-                variant="destructive"
-                size="sm"
-                onClick={onStopAutoMode}
-                data-testid="stop-auto-mode"
-              >
-                <StopCircle className="w-4 h-4 mr-2" />
-                Stop Auto Mode
-              </Button>
-            ) : (
-              <Button
-                variant="secondary"
-                size="sm"
-                onClick={onStartAutoMode}
-                data-testid="start-auto-mode"
-              >
-                <Play className="w-4 h-4 mr-2" />
-                Auto Mode
-              </Button>
-            )}
-          </>
+          <div className="flex items-center gap-2 px-3 py-1.5 rounded-lg bg-secondary border border-border">
+            <Label
+              htmlFor="auto-mode-toggle"
+              className="text-sm font-medium cursor-pointer"
+            >
+              Auto Mode
+            </Label>
+            <Switch
+              id="auto-mode-toggle"
+              checked={isAutoModeRunning}
+              onCheckedChange={onAutoModeToggle}
+              data-testid="auto-mode-toggle"
+            />
+          </div>
        )}

        <HotkeyButton
--- a/apps/app/src/components/views/board-view/components/kanban-card.tsx
+++ b/apps/app/src/components/views/board-view/components/kanban-card.tsx
@@ -257,7 +257,7 @@ export const KanbanCard = memo(function KanbanCard({
    feature.status === "backlog" ||
    feature.status === "waiting_approval" ||
    feature.status === "verified" ||
-    (feature.skipTests && !isCurrentAutoTask);
+    (feature.status === "in_progress" && !isCurrentAutoTask);
  const {
    attributes,
    listeners,
--- a/apps/app/src/components/views/board-view/dialogs/add-feature-dialog.tsx
+++ b/apps/app/src/components/views/board-view/dialogs/add-feature-dialog.tsx
@@ -43,6 +43,7 @@ import {
  ProfileQuickSelect,
  TestingTabContent,
  PrioritySelector,
+  BranchSelector,
 } from "../shared";
 import {
  DropdownMenu,
@@ -63,13 +64,14 @@ interface AddFeatureDialogProps {
    skipTests: boolean;
    model: AgentModel;
    thinkingLevel: ThinkingLevel;
-    branchName: string;
+    branchName: string; // Can be empty string to use current branch
    priority: number;
  }) => void;
  categorySuggestions: string[];
  branchSuggestions: string[];
  defaultSkipTests: boolean;
  defaultBranch?: string;
+  currentBranch?: string;
  isMaximized: boolean;
  showProfilesOnly: boolean;
  aiProfiles: AIProfile[];
@@ -83,10 +85,12 @@ export function AddFeatureDialog({
  branchSuggestions,
  defaultSkipTests,
  defaultBranch = "main",
+  currentBranch,
  isMaximized,
  showProfilesOnly,
  aiProfiles,
 }: AddFeatureDialogProps) {
+  const [useCurrentBranch, setUseCurrentBranch] = useState(true);
  const [newFeature, setNewFeature] = useState({
    category: "",
    description: "",
@@ -96,7 +100,7 @@ export function AddFeatureDialog({
    skipTests: false,
    model: "opus" as AgentModel,
    thinkingLevel: "none" as ThinkingLevel,
-    branchName: "main",
+    branchName: "",
    priority: 2 as number, // Default to medium priority
  });
  const [newFeaturePreviewMap, setNewFeaturePreviewMap] =
@@ -117,8 +121,9 @@ export function AddFeatureDialog({
      setNewFeature((prev) => ({
        ...prev,
        skipTests: defaultSkipTests,
-        branchName: defaultBranch,
+        branchName: defaultBranch || "",
      }));
+      setUseCurrentBranch(true);
    }
  }, [open, defaultSkipTests, defaultBranch]);

@@ -128,12 +133,24 @@ export function AddFeatureDialog({
      return;
    }

+    // Validate branch selection when "other branch" is selected
+    if (useWorktrees && !useCurrentBranch && !newFeature.branchName.trim()) {
+      toast.error("Please select a branch name");
+      return;
+    }
+
    const category = newFeature.category || "Uncategorized";
    const selectedModel = newFeature.model;
    const normalizedThinking = modelSupportsThinking(selectedModel)
      ? newFeature.thinkingLevel
      : "none";

+    // Use current branch if toggle is on (empty string = use current), otherwise use selected branch
+    // Important: Don't save the actual current branch name - empty string means "use current"
+    const finalBranchName = useCurrentBranch
+      ? ""
+      : newFeature.branchName || "";
+
    onAdd({
      category,
      description: newFeature.description,
@@ -143,7 +160,7 @@ export function AddFeatureDialog({
      skipTests: newFeature.skipTests,
      model: selectedModel,
      thinkingLevel: normalizedThinking,
-      branchName: newFeature.branchName,
+      branchName: finalBranchName,
      priority: newFeature.priority,
    });

@@ -158,8 +175,9 @@ export function AddFeatureDialog({
      model: "opus",
      priority: 2,
      thinkingLevel: "none",
-      branchName: defaultBranch,
+      branchName: "",
    });
+    setUseCurrentBranch(true);
    setNewFeaturePreviewMap(new Map());
    setShowAdvancedOptions(false);
    setDescriptionError(false);
@@ -359,22 +377,17 @@ export function AddFeatureDialog({
              />
            </div>
            {useWorktrees && (
-              <div className="space-y-2">
-                <Label htmlFor="branch">Target Branch</Label>
-                <BranchAutocomplete
-                  value={newFeature.branchName}
-                  onChange={(value) =>
-                    setNewFeature({ ...newFeature, branchName: value })
-                  }
-                  branches={branchSuggestions}
-                  placeholder="Select or create branch..."
-                  data-testid="feature-branch-input"
-                />
-                <p className="text-xs text-muted-foreground">
-                  Work will be done in this branch. A worktree will be created if
-                  needed.
-                </p>
-              </div>
+              <BranchSelector
+                useCurrentBranch={useCurrentBranch}
+                onUseCurrentBranchChange={setUseCurrentBranch}
+                branchName={newFeature.branchName}
+                onBranchNameChange={(value) =>
+                  setNewFeature({ ...newFeature, branchName: value })
+                }
+                branchSuggestions={branchSuggestions}
+                currentBranch={currentBranch}
+                testIdPrefix="feature"
+              />
            )}

            {/* Priority Selector */}
@@ -477,6 +490,11 @@ export function AddFeatureDialog({
            hotkey={{ key: "Enter", cmdCtrl: true }}
            hotkeyActive={open}
            data-testid="confirm-add-feature"
+            disabled={
+              useWorktrees &&
+              !useCurrentBranch &&
+              !newFeature.branchName.trim()
+            }
          >
            Add Feature
          </HotkeyButton>
--- a/apps/app/src/components/views/board-view/dialogs/archive-all-verified-dialog.tsx
+++ b/apps/app/src/components/views/board-view/dialogs/archive-all-verified-dialog.tsx
@@ -0,0 +1,55 @@
+"use client";
+
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import { Button } from "@/components/ui/button";
+import { Archive } from "lucide-react";
+
+interface ArchiveAllVerifiedDialogProps {
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  verifiedCount: number;
+  onConfirm: () => void;
+}
+
+export function ArchiveAllVerifiedDialog({
+  open,
+  onOpenChange,
+  verifiedCount,
+  onConfirm,
+}: ArchiveAllVerifiedDialogProps) {
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent data-testid="archive-all-verified-dialog">
+        <DialogHeader>
+          <DialogTitle>Archive All Verified Features</DialogTitle>
+          <DialogDescription>
+            Are you sure you want to archive all verified features? They will be
+            moved to the archive box.
+            {verifiedCount > 0 && (
+              <span className="block mt-2 text-yellow-500">
+                {verifiedCount} feature(s) will be archived.
+              </span>
+            )}
+          </DialogDescription>
+        </DialogHeader>
+        <DialogFooter>
+          <Button variant="ghost" onClick={() => onOpenChange(false)}>
+            Cancel
+          </Button>
+          <Button variant="default" onClick={onConfirm} data-testid="confirm-archive-all-verified">
+            <Archive className="w-4 h-4 mr-2" />
+            Archive All
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}
+
--- a/apps/app/src/components/views/board-view/dialogs/create-pr-dialog.tsx
+++ b/apps/app/src/components/views/board-view/dialogs/create-pr-dialog.tsx
@@ -53,14 +53,18 @@ export function CreatePRDialog({
  // Reset state when dialog opens or worktree changes
  useEffect(() => {
    if (open) {
-      // Only reset form fields, not the result states (prUrl, browserUrl, showBrowserFallback)
-      // These are set by the API response and should persist until dialog closes
+      // Reset form fields
      setTitle("");
      setBody("");
      setCommitMessage("");
      setBaseBranch("main");
      setIsDraft(false);
      setError(null);
+      // Also reset result states when opening for a new worktree
+      // This prevents showing stale PR URLs from previous worktrees
+      setPrUrl(null);
+      setBrowserUrl(null);
+      setShowBrowserFallback(false);
    } else {
      // Reset everything when dialog closes
      setTitle("");
@@ -105,7 +109,8 @@ export function CreatePRDialog({
              onClick: () => window.open(result.result!.prUrl!, "_blank"),
            },
          });
-          onCreated();
+          // Don't call onCreated() here - keep dialog open to show success message
+          // onCreated() will be called when user closes the dialog
        } else {
          // Branch was pushed successfully
          const prError = result.result.prError;
@@ -182,6 +187,9 @@ export function CreatePRDialog({
  };

  const handleClose = () => {
+    // Call onCreated() to refresh worktrees when dialog closes
+    // This ensures the worktree list is updated after any operation
+    onCreated();
    onOpenChange(false);
    // Reset state after dialog closes
    setTimeout(() => {
@@ -228,13 +236,18 @@ export function CreatePRDialog({
                Your PR is ready for review
              </p>
            </div>
-            <Button
-              onClick={() => window.open(prUrl, "_blank")}
-              className="gap-2"
-            >
-              <ExternalLink className="w-4 h-4" />
-              View Pull Request
-            </Button>
+            <div className="flex gap-2 justify-center">
+              <Button
+                onClick={() => window.open(prUrl, "_blank")}
+                className="gap-2"
+              >
+                <ExternalLink className="w-4 h-4" />
+                View Pull Request
+              </Button>
+              <Button variant="outline" onClick={handleClose}>
+                Close
+              </Button>
+            </div>
          </div>
        ) : shouldShowBrowserFallback ? (
          <div className="py-6 text-center space-y-4">
--- a/apps/app/src/components/views/board-view/dialogs/edit-feature-dialog.tsx
+++ b/apps/app/src/components/views/board-view/dialogs/edit-feature-dialog.tsx
@@ -44,6 +44,7 @@ import {
  ProfileQuickSelect,
  TestingTabContent,
  PrioritySelector,
+  BranchSelector,
 } from "../shared";
 import {
  DropdownMenu,
@@ -66,12 +67,13 @@ interface EditFeatureDialogProps {
      model: AgentModel;
      thinkingLevel: ThinkingLevel;
      imagePaths: DescriptionImagePath[];
-      branchName: string;
+      branchName: string; // Can be empty string to use current branch
      priority: number;
    }
  ) => void;
  categorySuggestions: string[];
  branchSuggestions: string[];
+  currentBranch?: string;
  isMaximized: boolean;
  showProfilesOnly: boolean;
  aiProfiles: AIProfile[];
@@ -84,12 +86,17 @@ export function EditFeatureDialog({
  onUpdate,
  categorySuggestions,
  branchSuggestions,
+  currentBranch,
  isMaximized,
  showProfilesOnly,
  aiProfiles,
  allFeatures,
 }: EditFeatureDialogProps) {
  const [editingFeature, setEditingFeature] = useState<Feature | null>(feature);
+  const [useCurrentBranch, setUseCurrentBranch] = useState(() => {
+    // If feature has no branchName, default to using current branch
+    return !feature?.branchName;
+  });
  const [editFeaturePreviewMap, setEditFeaturePreviewMap] =
    useState<ImagePreviewMap>(() => new Map());
  const [showEditAdvancedOptions, setShowEditAdvancedOptions] = useState(false);
@@ -107,12 +114,27 @@ export function EditFeatureDialog({
    if (!feature) {
      setEditFeaturePreviewMap(new Map());
      setShowEditAdvancedOptions(false);
+    } else {
+      // If feature has no branchName, default to using current branch
+      setUseCurrentBranch(!feature.branchName);
    }
  }, [feature]);

  const handleUpdate = () => {
    if (!editingFeature) return;

+    // Validate branch selection when "other branch" is selected and branch selector is enabled
+    const isBranchSelectorEnabled = editingFeature.status === "backlog";
+    if (
+      useWorktrees &&
+      isBranchSelectorEnabled &&
+      !useCurrentBranch &&
+      !editingFeature.branchName?.trim()
+    ) {
+      toast.error("Please select a branch name");
+      return;
+    }
+
    const selectedModel = (editingFeature.model ?? "opus") as AgentModel;
    const normalizedThinking: ThinkingLevel = modelSupportsThinking(
      selectedModel
@@ -120,6 +142,12 @@ export function EditFeatureDialog({
      ? editingFeature.thinkingLevel ?? "none"
      : "none";

+    // Use current branch if toggle is on (empty string = use current), otherwise use selected branch
+    // Important: Don't save the actual current branch name - empty string means "use current"
+    const finalBranchName = useCurrentBranch
+      ? ""
+      : editingFeature.branchName || "";
+
    const updates = {
      category: editingFeature.category,
      description: editingFeature.description,
@@ -128,7 +156,7 @@ export function EditFeatureDialog({
      model: selectedModel,
      thinkingLevel: normalizedThinking,
      imagePaths: editingFeature.imagePaths ?? [],
-      branchName: editingFeature.branchName ?? "main",
+      branchName: finalBranchName,
      priority: editingFeature.priority ?? 2,
    };

@@ -339,33 +367,21 @@ export function EditFeatureDialog({
              />
            </div>
            {useWorktrees && (
-              <div className="space-y-2">
-                <Label htmlFor="edit-branch">Target Branch</Label>
-                <BranchAutocomplete
-                  value={editingFeature.branchName ?? "main"}
-                  onChange={(value) =>
-                    setEditingFeature({
-                      ...editingFeature,
-                      branchName: value,
-                    })
-                  }
-                  branches={branchSuggestions}
-                  placeholder="Select or create branch..."
-                  data-testid="edit-feature-branch"
-                  disabled={editingFeature.status !== "backlog"}
-                />
-                {editingFeature.status !== "backlog" && (
-                  <p className="text-xs text-muted-foreground">
-                    Branch cannot be changed after work has started.
-                  </p>
-                )}
-                {editingFeature.status === "backlog" && (
-                  <p className="text-xs text-muted-foreground">
-                    Work will be done in this branch. A worktree will be created
-                    if needed.
-                  </p>
-                )}
-              </div>
+              <BranchSelector
+                useCurrentBranch={useCurrentBranch}
+                onUseCurrentBranchChange={setUseCurrentBranch}
+                branchName={editingFeature.branchName ?? ""}
+                onBranchNameChange={(value) =>
+                  setEditingFeature({
+                    ...editingFeature,
+                    branchName: value,
+                  })
+                }
+                branchSuggestions={branchSuggestions}
+                currentBranch={currentBranch}
+                disabled={editingFeature.status !== "backlog"}
+                testIdPrefix="edit-feature"
+              />
            )}

            {/* Priority Selector */}
@@ -486,6 +502,12 @@ export function EditFeatureDialog({
              hotkey={{ key: "Enter", cmdCtrl: true }}
              hotkeyActive={!!editingFeature}
              data-testid="confirm-edit-feature"
+              disabled={
+                useWorktrees &&
+                editingFeature.status === "backlog" &&
+                !useCurrentBranch &&
+                !editingFeature.branchName?.trim()
+              }
            >
              Save Changes
            </HotkeyButton>
--- a/apps/app/src/components/views/board-view/dialogs/index.ts
+++ b/apps/app/src/components/views/board-view/dialogs/index.ts
@@ -1,7 +1,7 @@
 export { AddFeatureDialog } from "./add-feature-dialog";
 export { AgentOutputModal } from "./agent-output-modal";
 export { CompletedFeaturesModal } from "./completed-features-modal";
-export { DeleteAllVerifiedDialog } from "./delete-all-verified-dialog";
+export { ArchiveAllVerifiedDialog } from "./archive-all-verified-dialog";
 export { DeleteCompletedFeatureDialog } from "./delete-completed-feature-dialog";
 export { EditFeatureDialog } from "./edit-feature-dialog";
 export { FeatureSuggestionsDialog } from "./feature-suggestions-dialog";
--- a/apps/app/src/components/views/board-view/hooks/use-board-actions.ts
+++ b/apps/app/src/components/views/board-view/hooks/use-board-actions.ts
@@ -76,67 +76,13 @@ export function useBoardActions({
    moveFeature,
    useWorktrees,
    enableDependencyBlocking,
+    isPrimaryWorktreeBranch,
+    getPrimaryWorktreeBranch,
  } = useAppStore();
  const autoMode = useAutoMode();

-  /**
-   * Get or create the worktree path for a feature based on its branchName.
-   * - If branchName is "main" or empty, returns the project path
-   * - Otherwise, creates a worktree for that branch if needed
-   */
-  const getOrCreateWorktreeForFeature = useCallback(
-    async (feature: Feature): Promise<string | null> => {
-      if (!projectPath) return null;
-
-      const branchName = feature.branchName || "main";
-
-      // If targeting main branch, use the project path directly
-      if (branchName === "main" || branchName === "master") {
-        return projectPath;
-      }
-
-      // For other branches, create a worktree if it doesn't exist
-      try {
-        const api = getElectronAPI();
-        if (!api?.worktree?.create) {
-          console.error("[BoardActions] Worktree API not available");
-          return projectPath;
-        }
-
-        // Try to create the worktree (will return existing if already exists)
-        const result = await api.worktree.create(projectPath, branchName);
-
-        if (result.success && result.worktree) {
-          console.log(
-            `[BoardActions] Worktree ready for branch "${branchName}": ${result.worktree.path}`
-          );
-          if (result.worktree.isNew) {
-            toast.success(`Worktree created for branch "${branchName}"`, {
-              description: "A new worktree was created for this feature.",
-            });
-          }
-          return result.worktree.path;
-        } else {
-          console.error(
-            "[BoardActions] Failed to create worktree:",
-            result.error
-          );
-          toast.error("Failed to create worktree", {
-            description:
-              result.error || "Could not create worktree for this branch.",
-          });
-          return projectPath; // Fall back to project path
-        }
-      } catch (error) {
-        console.error("[BoardActions] Error creating worktree:", error);
-        toast.error("Error creating worktree", {
-          description: error instanceof Error ? error.message : "Unknown error",
-        });
-        return projectPath; // Fall back to project path
-      }
-    },
-    [projectPath]
-  );
+  // Note: getOrCreateWorktreeForFeature removed - worktrees are now created server-side
+  // at execution time based on feature.branchName

  const handleAddFeature = useCallback(
    async (featureData: {
@@ -151,34 +97,26 @@ export function useBoardActions({
      branchName: string;
      priority: number;
    }) => {
-      let worktreePath: string | undefined;
-
-      // If worktrees are enabled and a non-main branch is selected, create the worktree
-      if (useWorktrees && featureData.branchName) {
-        const branchName = featureData.branchName;
-        if (branchName !== "main" && branchName !== "master") {
-          // Create a temporary feature-like object for getOrCreateWorktreeForFeature
-          const tempFeature = { branchName } as Feature;
-          const path = await getOrCreateWorktreeForFeature(tempFeature);
-          if (path && path !== projectPath) {
-            worktreePath = path;
-            // Refresh worktree selector after creating worktree
-            onWorktreeCreated?.();
-          }
-        }
-      }
+      // Simplified: Only store branchName, no worktree creation on add
+      // Worktrees are created at execution time (when feature starts)
+      // Empty string means user chose "use current branch" - don't save a branch name
+      const finalBranchName =
+        featureData.branchName === ""
+          ? undefined
+          : featureData.branchName || undefined;

      const newFeatureData = {
        ...featureData,
        status: "backlog" as const,
-        worktreePath,
+        branchName: finalBranchName,
+        // No worktreePath - derived at runtime from branchName
      };
      const createdFeature = addFeature(newFeatureData);
      // Must await to ensure feature exists on server before user can drag it
      await persistFeatureCreate(createdFeature);
      saveCategory(featureData.category);
    },
-    [addFeature, persistFeatureCreate, saveCategory, useWorktrees, getOrCreateWorktreeForFeature, projectPath, onWorktreeCreated]
+    [addFeature, persistFeatureCreate, saveCategory]
  );

  const handleUpdateFeature = useCallback(
@@ -196,44 +134,13 @@ export function useBoardActions({
        priority: number;
      }
    ) => {
-      // Get the current feature to check if branch is changing
-      const currentFeature = features.find((f) => f.id === featureId);
-      const currentBranch = currentFeature?.branchName || "main";
-      const newBranch = updates.branchName || "main";
-      const branchIsChanging = currentBranch !== newBranch;
+      const finalBranchName =
+        updates.branchName === "" ? undefined : updates.branchName || undefined;

-      let worktreePath: string | undefined;
-      let shouldClearWorktreePath = false;
-
-      // If worktrees are enabled and branch is changing to a non-main branch, create worktree
-      if (useWorktrees && branchIsChanging) {
-        if (newBranch === "main" || newBranch === "master") {
-          // Changing to main - clear the worktreePath
-          shouldClearWorktreePath = true;
-        } else {
-          // Changing to a feature branch - create worktree if needed
-          const tempFeature = { branchName: newBranch } as Feature;
-          const path = await getOrCreateWorktreeForFeature(tempFeature);
-          if (path && path !== projectPath) {
-            worktreePath = path;
-            // Refresh worktree selector after creating worktree
-            onWorktreeCreated?.();
-          }
-        }
-      }
-
-      // Build final updates with worktreePath if it was changed
-      let finalUpdates: typeof updates & { worktreePath?: string };
-      if (branchIsChanging && useWorktrees) {
-        if (shouldClearWorktreePath) {
-          // Use null to clear the value in persistence (cast to work around type system)
-          finalUpdates = { ...updates, worktreePath: null as unknown as string | undefined };
-        } else {
-          finalUpdates = { ...updates, worktreePath };
-        }
-      } else {
-        finalUpdates = updates;
-      }
+      const finalUpdates = {
+        ...updates,
+        branchName: finalBranchName,
+      };

      updateFeature(featureId, finalUpdates);
      persistFeatureUpdate(featureId, finalUpdates);
@@ -242,7 +149,7 @@ export function useBoardActions({
      }
      setEditingFeature(null);
    },
-    [updateFeature, persistFeatureUpdate, saveCategory, setEditingFeature, features, useWorktrees, getOrCreateWorktreeForFeature, projectPath, onWorktreeCreated]
+    [updateFeature, persistFeatureUpdate, saveCategory, setEditingFeature]
  );

  const handleDeleteFeature = useCallback(
@@ -307,21 +214,18 @@ export function useBoardActions({
          return;
        }

-        // Use the feature's assigned worktreePath (set when moving to in_progress)
-        // This ensures work happens in the correct worktree based on the feature's branchName
-        const featureWorktreePath = feature.worktreePath;
-
+        // Server derives workDir from feature.branchName at execution time
        const result = await api.autoMode.runFeature(
          currentProject.path,
          feature.id,
-          useWorktrees,
-          featureWorktreePath || undefined
+          useWorktrees
+          // No worktreePath - server derives from feature.branchName
        );

        if (result.success) {
          console.log(
-            "[Board] Feature run started successfully in worktree:",
-            featureWorktreePath || "main"
+            "[Board] Feature run started successfully, branch:",
+            feature.branchName || "default"
          );
        } else {
          console.error("[Board] Failed to run feature:", result.error);
@@ -350,10 +254,12 @@ export function useBoardActions({
      if (enableDependencyBlocking) {
        const blockingDeps = getBlockingDependencies(feature, features);
        if (blockingDeps.length > 0) {
-          const depDescriptions = blockingDeps.map(depId => {
-            const dep = features.find(f => f.id === depId);
-            return dep ? truncateDescription(dep.description, 40) : depId;
-          }).join(", ");
+          const depDescriptions = blockingDeps
+            .map((depId) => {
+              const dep = features.find((f) => f.id === depId);
+              return dep ? truncateDescription(dep.description, 40) : depId;
+            })
+            .join(", ");

          toast.warning("Starting feature with incomplete dependencies", {
            description: `This feature depends on: ${depDescriptions}`,
@@ -372,7 +278,14 @@ export function useBoardActions({
      await handleRunFeature(feature);
      return true;
    },
-    [autoMode, enableDependencyBlocking, features, updateFeature, persistFeatureUpdate, handleRunFeature]
+    [
+      autoMode,
+      enableDependencyBlocking,
+      features,
+      updateFeature,
+      persistFeatureUpdate,
+      handleRunFeature,
+    ]
  );

  const handleVerifyFeature = useCallback(
@@ -489,7 +402,6 @@ export function useBoardActions({

    const featureId = followUpFeature.id;
    const featureDescription = followUpFeature.description;
-    const prompt = followUpPrompt;

    const api = getElectronAPI();
    if (!api?.autoMode?.followUpFeature) {
@@ -521,15 +433,14 @@ export function useBoardActions({
    });

    const imagePaths = followUpImagePaths.map((img) => img.path);
-    // Use the feature's worktreePath to ensure work happens in the correct branch
-    const featureWorktreePath = followUpFeature.worktreePath;
+    // Server derives workDir from feature.branchName at execution time
    api.autoMode
      .followUpFeature(
        currentProject.path,
        followUpFeature.id,
        followUpPrompt,
-        imagePaths,
-        featureWorktreePath
+        imagePaths
+        // No worktreePath - server derives from feature.branchName
      )
      .catch((error) => {
        console.error("[Board] Error sending follow-up:", error);
@@ -569,11 +480,11 @@ export function useBoardActions({
          return;
        }

-        // Pass the feature's worktreePath to ensure commits happen in the correct worktree
+        // Server derives workDir from feature.branchName
        const result = await api.autoMode.commitFeature(
          currentProject.path,
-          feature.id,
-          feature.worktreePath
+          feature.id
+          // No worktreePath - server derives from feature.branchName
        );

        if (result.success) {
@@ -758,23 +669,25 @@ export function useBoardActions({
  const handleStartNextFeatures = useCallback(async () => {
    // Filter backlog features by the currently selected worktree branch
    // This ensures "G" only starts features from the filtered list
+    const primaryBranch = projectPath
+      ? getPrimaryWorktreeBranch(projectPath)
+      : null;
    const backlogFeatures = features.filter((f) => {
      if (f.status !== "backlog") return false;

-      // Determine the feature's branch (default to "main" if not set)
-      const featureBranch = f.branchName || "main";
+      // Determine the feature's branch (default to primary branch if not set)
+      const featureBranch = f.branchName || primaryBranch || "main";

-      // If no worktree is selected (currentWorktreeBranch is null or main-like),
-      // show features with no branch or "main"/"master" branch
+      // If no worktree is selected (currentWorktreeBranch is null or matches primary),
+      // show features with no branch or primary branch
      if (
        !currentWorktreeBranch ||
-        currentWorktreeBranch === "main" ||
-        currentWorktreeBranch === "master"
+        (projectPath &&
+          isPrimaryWorktreeBranch(projectPath, currentWorktreeBranch))
      ) {
        return (
          !f.branchName ||
-          featureBranch === "main" ||
-          featureBranch === "master"
+          (projectPath && isPrimaryWorktreeBranch(projectPath, featureBranch))
        );
      }

@@ -794,57 +707,65 @@ export function useBoardActions({
    }

    if (backlogFeatures.length === 0) {
+      const isOnPrimaryBranch =
+        !currentWorktreeBranch ||
+        (projectPath &&
+          isPrimaryWorktreeBranch(projectPath, currentWorktreeBranch));
      toast.info("Backlog empty", {
-        description:
-          currentWorktreeBranch &&
-          currentWorktreeBranch !== "main" &&
-          currentWorktreeBranch !== "master"
-            ? `No features in backlog for branch "${currentWorktreeBranch}".`
-            : "No features in backlog to start.",
+        description: !isOnPrimaryBranch
+          ? `No features in backlog for branch "${currentWorktreeBranch}".`
+          : "No features in backlog to start.",
      });
      return;
    }

    // Sort by priority (lower number = higher priority, priority 1 is highest)
-    // This matches the auto mode service behavior for consistency
-    const sortedBacklog = [...backlogFeatures].sort(
-      (a, b) => (a.priority || 999) - (b.priority || 999)
-    );
+    // Features with blocking dependencies are sorted to the end
+    const sortedBacklog = [...backlogFeatures].sort((a, b) => {
+      const aBlocked = enableDependencyBlocking
+        ? getBlockingDependencies(a, features).length > 0
+        : false;
+      const bBlocked = enableDependencyBlocking
+        ? getBlockingDependencies(b, features).length > 0
+        : false;
+
+      // Blocked features go to the end
+      if (aBlocked && !bBlocked) return 1;
+      if (!aBlocked && bBlocked) return -1;
+
+      // Within same blocked/unblocked group, sort by priority
+      return (a.priority || 999) - (b.priority || 999);
+    });
+
+    // Find the first feature without blocking dependencies
+    const featureToStart = sortedBacklog.find((f) => {
+      if (!enableDependencyBlocking) return true;
+      return getBlockingDependencies(f, features).length === 0;
+    });
+
+    if (!featureToStart) {
+      toast.info("No eligible features", {
+        description:
+          "All backlog features have unmet dependencies. Complete their dependencies first.",
+      });
+      return;
+    }

    // Start only one feature per keypress (user must press again for next)
-    const featuresToStart = sortedBacklog.slice(0, 1);
-
-    for (const feature of featuresToStart) {
-      // Only create worktrees if the feature is enabled
-      let worktreePath: string | null = null;
-      if (useWorktrees) {
-        // Get or create worktree based on the feature's assigned branch (same as drag-to-in-progress)
-        worktreePath = await getOrCreateWorktreeForFeature(feature);
-        if (worktreePath) {
-          await persistFeatureUpdate(feature.id, { worktreePath });
-        }
-        // Refresh worktree selector after creating worktree
-        onWorktreeCreated?.();
-      }
-      // Start the implementation
-      // Pass feature with worktreePath so handleRunFeature uses the correct path
-      await handleStartImplementation({
-        ...feature,
-        worktreePath: worktreePath || undefined,
-      });
-    }
+    // Simplified: No worktree creation on client - server derives workDir from feature.branchName
+    await handleStartImplementation(featureToStart);
  }, [
    features,
    runningAutoTasks,
    handleStartImplementation,
-    getOrCreateWorktreeForFeature,
-    persistFeatureUpdate,
-    onWorktreeCreated,
    currentWorktreeBranch,
-    useWorktrees,
+    projectPath,
+    isPrimaryWorktreeBranch,
+    getPrimaryWorktreeBranch,
+    enableDependencyBlocking,
  ]);

-  const handleDeleteAllVerified = useCallback(async () => {
+  const handleArchiveAllVerified = useCallback(async () => {
    const verifiedFeatures = features.filter((f) => f.status === "verified");

    for (const feature of verifiedFeatures) {
@@ -853,22 +774,29 @@ export function useBoardActions({
        try {
          await autoMode.stopFeature(feature.id);
        } catch (error) {
-          console.error("[Board] Error stopping feature before delete:", error);
+          console.error(
+            "[Board] Error stopping feature before archive:",
+            error
+          );
        }
      }
-      removeFeature(feature.id);
-      persistFeatureDelete(feature.id);
+      // Archive the feature by setting status to completed
+      const updates = {
+        status: "completed" as const,
+      };
+      updateFeature(feature.id, updates);
+      persistFeatureUpdate(feature.id, updates);
    }

-    toast.success("All verified features deleted", {
-      description: `Deleted ${verifiedFeatures.length} feature(s).`,
+    toast.success("All verified features archived", {
+      description: `Archived ${verifiedFeatures.length} feature(s).`,
    });
  }, [
    features,
    runningAutoTasks,
    autoMode,
-    removeFeature,
-    persistFeatureDelete,
+    updateFeature,
+    persistFeatureUpdate,
  ]);

  return {
@@ -890,6 +818,6 @@ export function useBoardActions({
    handleOutputModalNumberKeyPress,
    handleForceStopFeature,
    handleStartNextFeatures,
-    handleDeleteAllVerified,
+    handleArchiveAllVerified,
  };
 }
--- a/apps/app/src/components/views/board-view/hooks/use-board-column-features.ts
+++ b/apps/app/src/components/views/board-view/hooks/use-board-column-features.ts
@@ -1,7 +1,6 @@
 import { useMemo, useCallback } from "react";
-import { Feature } from "@/store/app-store";
-import { resolveDependencies } from "@/lib/dependency-resolver";
-import { pathsEqual } from "@/lib/utils";
+import { Feature, useAppStore } from "@/store/app-store";
+import { resolveDependencies, getBlockingDependencies } from "@/lib/dependency-resolver";

 type ColumnId = Feature["status"];

@@ -56,26 +55,24 @@ export function useBoardColumnFeatures({
      // If feature has a running agent, always show it in "in_progress"
      const isRunning = runningAutoTasks.includes(f.id);

-      // Check if feature matches the current worktree
-      // Match by worktreePath if set, OR by branchName if set
-      // Features with neither are considered unassigned (show on ALL worktrees)
-      const featureBranch = f.branchName || "main";
-      const hasWorktreeAssigned = f.worktreePath || f.branchName;
+      // Check if feature matches the current worktree by branchName
+      // Features without branchName are considered unassigned (show only on primary worktree)
+      const featureBranch = f.branchName;

      let matchesWorktree: boolean;
-      if (!hasWorktreeAssigned) {
-        // No worktree or branch assigned - show on ALL worktrees (unassigned)
-        matchesWorktree = true;
-      } else if (f.worktreePath) {
-        // Has worktreePath - match by path (use pathsEqual for cross-platform compatibility)
-        matchesWorktree = pathsEqual(f.worktreePath, effectiveWorktreePath);
+      if (!featureBranch) {
+        // No branch assigned - show only on primary worktree
+        const isViewingPrimary = currentWorktreePath === null;
+        matchesWorktree = isViewingPrimary;
      } else if (effectiveBranch === null) {
        // We're viewing main but branch hasn't been initialized yet
        // (worktrees disabled or haven't loaded yet).
-        // Show features assigned to main/master branch since we're on the main worktree.
-        matchesWorktree = featureBranch === "main" || featureBranch === "master";
+        // Show features assigned to primary worktree's branch.
+        matchesWorktree = projectPath
+          ? useAppStore.getState().isPrimaryWorktreeBranch(projectPath, featureBranch)
+          : false;
      } else {
-        // Has branchName but no worktreePath - match by branch name
+        // Match by branch name
        matchesWorktree = featureBranch === effectiveBranch;
      }

@@ -111,7 +108,29 @@ export function useBoardColumnFeatures({
    // Within the same dependency level, features are sorted by priority
    if (map.backlog.length > 0) {
      const { orderedFeatures } = resolveDependencies(map.backlog);
-      map.backlog = orderedFeatures;
+
+      // Get all features to check blocking dependencies against
+      const allFeatures = features;
+      const enableDependencyBlocking = useAppStore.getState().enableDependencyBlocking;
+
+      // Sort blocked features to the end of the backlog
+      // This keeps the dependency order within each group (unblocked/blocked)
+      if (enableDependencyBlocking) {
+        const unblocked: Feature[] = [];
+        const blocked: Feature[] = [];
+
+        for (const f of orderedFeatures) {
+          if (getBlockingDependencies(f, allFeatures).length > 0) {
+            blocked.push(f);
+          } else {
+            unblocked.push(f);
+          }
+        }
+
+        map.backlog = [...unblocked, ...blocked];
+      } else {
+        map.backlog = orderedFeatures;
+      }
    }

    return map;
--- a/apps/app/src/components/views/board-view/hooks/use-board-drag-drop.ts
+++ b/apps/app/src/components/views/board-view/hooks/use-board-drag-drop.ts
@@ -4,7 +4,6 @@ import { Feature } from "@/store/app-store";
 import { useAppStore } from "@/store/app-store";
 import { toast } from "sonner";
 import { COLUMNS, ColumnId } from "../constants";
-import { getElectronAPI } from "@/lib/electron";

 interface UseBoardDragDropProps {
  features: Feature[];
@@ -29,62 +28,10 @@ export function useBoardDragDrop({
  onWorktreeCreated,
 }: UseBoardDragDropProps) {
  const [activeFeature, setActiveFeature] = useState<Feature | null>(null);
-  const { moveFeature, useWorktrees } = useAppStore();
+  const { moveFeature } = useAppStore();

-  /**
-   * Get or create the worktree path for a feature based on its branchName.
-   * - If branchName is "main" or empty, returns the project path
-   * - Otherwise, creates a worktree for that branch if needed
-   */
-  const getOrCreateWorktreeForFeature = useCallback(
-    async (feature: Feature): Promise<string | null> => {
-      if (!projectPath) return null;
-
-      const branchName = feature.branchName || "main";
-
-      // If targeting main branch, use the project path directly
-      if (branchName === "main" || branchName === "master") {
-        return projectPath;
-      }
-
-      // For other branches, create a worktree if it doesn't exist
-      try {
-        const api = getElectronAPI();
-        if (!api?.worktree?.create) {
-          console.error("[DragDrop] Worktree API not available");
-          return projectPath;
-        }
-
-        // Try to create the worktree (will return existing if already exists)
-        const result = await api.worktree.create(projectPath, branchName);
-
-        if (result.success && result.worktree) {
-          console.log(
-            `[DragDrop] Worktree ready for branch "${branchName}": ${result.worktree.path}`
-          );
-          if (result.worktree.isNew) {
-            toast.success(`Worktree created for branch "${branchName}"`, {
-              description: "A new worktree was created for this feature.",
-            });
-          }
-          return result.worktree.path;
-        } else {
-          console.error("[DragDrop] Failed to create worktree:", result.error);
-          toast.error("Failed to create worktree", {
-            description: result.error || "Could not create worktree for this branch.",
-          });
-          return projectPath; // Fall back to project path
-        }
-      } catch (error) {
-        console.error("[DragDrop] Error creating worktree:", error);
-        toast.error("Error creating worktree", {
-          description: error instanceof Error ? error.message : "Unknown error",
-        });
-        return projectPath; // Fall back to project path
-      }
-    },
-    [projectPath]
-  );
+  // Note: getOrCreateWorktreeForFeature removed - worktrees are now created server-side
+  // at execution time based on feature.branchName

  const handleDragStart = useCallback(
    (event: DragStartEvent) => {
@@ -118,17 +65,13 @@ export function useBoardDragDrop({
      // - Backlog items can always be dragged
      // - waiting_approval items can always be dragged (to allow manual verification via drag)
      // - verified items can always be dragged (to allow moving back to waiting_approval)
-      // - skipTests (non-TDD) items can be dragged between in_progress and verified
-      // - Non-skipTests (TDD) items that are in progress cannot be dragged (they are running)
-      if (
-        draggedFeature.status !== "backlog" &&
-        draggedFeature.status !== "waiting_approval" &&
-        draggedFeature.status !== "verified"
-      ) {
-        // Only allow dragging in_progress if it's a skipTests feature and not currently running
-        if (!draggedFeature.skipTests || isRunningTask) {
+      // - in_progress items can be dragged (but not if they're currently running)
+      // - Non-skipTests (TDD) items that are in progress cannot be dragged if they are running
+      if (draggedFeature.status === "in_progress") {
+        // Only allow dragging in_progress if it's not currently running
+        if (isRunningTask) {
          console.log(
-            "[Board] Cannot drag feature - TDD feature or currently running"
+            "[Board] Cannot drag feature - currently running"
          );
          return;
        }
@@ -154,23 +97,13 @@ export function useBoardDragDrop({
      if (targetStatus === draggedFeature.status) return;

      // Handle different drag scenarios
+      // Note: Worktrees are created server-side at execution time based on feature.branchName
      if (draggedFeature.status === "backlog") {
        // From backlog
        if (targetStatus === "in_progress") {
-          // Only create worktrees if the feature is enabled
-          let worktreePath: string | null = null;
-          if (useWorktrees) {
-            // Get or create worktree based on the feature's assigned branch
-            worktreePath = await getOrCreateWorktreeForFeature(draggedFeature);
-            if (worktreePath) {
-              await persistFeatureUpdate(featureId, { worktreePath });
-            }
-            // Refresh worktree selector after moving to in_progress
-            onWorktreeCreated?.();
-          }
          // Use helper function to handle concurrency check and start implementation
-          // Pass feature with worktreePath so handleRunFeature uses the correct path
-          await handleStartImplementation({ ...draggedFeature, worktreePath: worktreePath || undefined });
+          // Server will derive workDir from feature.branchName
+          await handleStartImplementation(draggedFeature);
        } else {
          moveFeature(featureId, targetStatus);
          persistFeatureUpdate(featureId, { status: targetStatus });
@@ -195,11 +128,10 @@ export function useBoardDragDrop({
        } else if (targetStatus === "backlog") {
          // Allow moving waiting_approval cards back to backlog
          moveFeature(featureId, "backlog");
-          // Clear justFinishedAt timestamp and worktreePath when moving back to backlog
+          // Clear justFinishedAt timestamp when moving back to backlog
          persistFeatureUpdate(featureId, {
            status: "backlog",
            justFinishedAt: undefined,
-            worktreePath: undefined,
          });
          toast.info("Feature moved to backlog", {
            description: `Moved to Backlog: ${draggedFeature.description.slice(
@@ -208,13 +140,23 @@ export function useBoardDragDrop({
            )}${draggedFeature.description.length > 50 ? "..." : ""}`,
          });
        }
-      } else if (draggedFeature.skipTests) {
-        // skipTests feature being moved between in_progress and verified
-        if (
+      } else if (draggedFeature.status === "in_progress") {
+        // Handle in_progress features being moved
+        if (targetStatus === "backlog") {
+          // Allow moving in_progress cards back to backlog
+          moveFeature(featureId, "backlog");
+          persistFeatureUpdate(featureId, { status: "backlog" });
+          toast.info("Feature moved to backlog", {
+            description: `Moved to Backlog: ${draggedFeature.description.slice(
+              0,
+              50
+            )}${draggedFeature.description.length > 50 ? "..." : ""}`,
+          });
+        } else if (
          targetStatus === "verified" &&
-          draggedFeature.status === "in_progress"
+          draggedFeature.skipTests
        ) {
-          // Manual verify via drag
+          // Manual verify via drag (only for skipTests features)
          moveFeature(featureId, "verified");
          persistFeatureUpdate(featureId, { status: "verified" });
          toast.success("Feature verified", {
@@ -223,7 +165,10 @@ export function useBoardDragDrop({
              50
            )}${draggedFeature.description.length > 50 ? "..." : ""}`,
          });
-        } else if (
+        }
+      } else if (draggedFeature.skipTests) {
+        // skipTests feature being moved between verified and waiting_approval
+        if (
          targetStatus === "waiting_approval" &&
          draggedFeature.status === "verified"
        ) {
@@ -237,10 +182,9 @@ export function useBoardDragDrop({
            )}${draggedFeature.description.length > 50 ? "..." : ""}`,
          });
        } else if (targetStatus === "backlog") {
-          // Allow moving skipTests cards back to backlog
+          // Allow moving skipTests cards back to backlog (from verified)
          moveFeature(featureId, "backlog");
-          // Clear worktreePath when moving back to backlog
-          persistFeatureUpdate(featureId, { status: "backlog", worktreePath: undefined });
+          persistFeatureUpdate(featureId, { status: "backlog" });
          toast.info("Feature moved to backlog", {
            description: `Moved to Backlog: ${draggedFeature.description.slice(
              0,
@@ -263,8 +207,7 @@ export function useBoardDragDrop({
        } else if (targetStatus === "backlog") {
          // Allow moving verified cards back to backlog
          moveFeature(featureId, "backlog");
-          // Clear worktreePath when moving back to backlog
-          persistFeatureUpdate(featureId, { status: "backlog", worktreePath: undefined });
+          persistFeatureUpdate(featureId, { status: "backlog" });
          toast.info("Feature moved to backlog", {
            description: `Moved to Backlog: ${draggedFeature.description.slice(
              0,
@@ -280,9 +223,6 @@ export function useBoardDragDrop({
      moveFeature,
      persistFeatureUpdate,
      handleStartImplementation,
-      getOrCreateWorktreeForFeature,
-      onWorktreeCreated,
-      useWorktrees,
    ]
  );

--- a/apps/app/src/components/views/board-view/hooks/use-board-effects.ts
+++ b/apps/app/src/components/views/board-view/hooks/use-board-effects.ts
@@ -1,7 +1,6 @@
-import { useEffect, useRef } from "react";
+import { useEffect } from "react";
 import { getElectronAPI } from "@/lib/electron";
 import { useAppStore } from "@/store/app-store";
-import { useAutoMode } from "@/hooks/use-auto-mode";

 interface UseBoardEffectsProps {
  currentProject: { path: string; id: string } | null;
@@ -28,8 +27,6 @@ export function useBoardEffects({
  isLoading,
  setFeaturesWithContext,
 }: UseBoardEffectsProps) {
-  const autoMode = useAutoMode();
-
  // Make current project available globally for modal
  useEffect(() => {
    if (currentProject) {
@@ -101,8 +98,7 @@ export function useBoardEffects({
        const status = await api.autoMode.status(currentProject.path);
        if (status.success) {
          const projectId = currentProject.id;
-          const { clearRunningTasks, addRunningTask, setAutoModeRunning } =
-            useAppStore.getState();
+          const { clearRunningTasks, addRunningTask } = useAppStore.getState();

          if (status.runningFeatures) {
            console.log(
@@ -116,14 +112,6 @@ export function useBoardEffects({
              addRunningTask(projectId, featureId);
            });
          }
-
-          const isAutoModeRunning =
-            status.autoLoopRunning ?? status.isRunning ?? false;
-          console.log(
-            "[Board] Syncing auto mode running state:",
-            isAutoModeRunning
-          );
-          setAutoModeRunning(projectId, isAutoModeRunning);
        }
      } catch (error) {
        console.error("[Board] Failed to sync running tasks:", error);
--- a/apps/app/src/components/views/board-view/kanban-board.tsx
+++ b/apps/app/src/components/views/board-view/kanban-board.tsx
@@ -14,7 +14,7 @@ import { HotkeyButton } from "@/components/ui/hotkey-button";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "@/components/ui/tooltip";
 import { KanbanColumn, KanbanCard } from "./components";
 import { Feature } from "@/store/app-store";
-import { FastForward, Lightbulb, Trash2 } from "lucide-react";
+import { FastForward, Lightbulb, Archive } from "lucide-react";
 import { useKeyboardShortcutsConfig } from "@/hooks/use-keyboard-shortcuts";
 import { COLUMNS, ColumnId } from "./constants";

@@ -53,7 +53,7 @@ interface KanbanBoardProps {
  onStartNextFeatures: () => void;
  onShowSuggestions: () => void;
  suggestionsCount: number;
-  onDeleteAllVerified: () => void;
+  onArchiveAllVerified: () => void;
 }

 export function KanbanBoard({
@@ -83,7 +83,7 @@ export function KanbanBoard({
  onStartNextFeatures,
  onShowSuggestions,
  suggestionsCount,
-  onDeleteAllVerified,
+  onArchiveAllVerified,
 }: KanbanBoardProps) {
  return (
    <div
@@ -115,12 +115,12 @@ export function KanbanBoard({
                    <Button
                      variant="ghost"
                      size="sm"
-                      className="h-6 px-2 text-xs text-destructive hover:text-destructive hover:bg-destructive/10"
-                      onClick={onDeleteAllVerified}
-                      data-testid="delete-all-verified-button"
+                      className="h-6 px-2 text-xs"
+                      onClick={onArchiveAllVerified}
+                      data-testid="archive-all-verified-button"
                    >
-                      <Trash2 className="w-3 h-3 mr-1" />
-                      Delete All
+                      <Archive className="w-3 h-3 mr-1" />
+                      Archive All
                    </Button>
                  ) : column.id === "backlog" ? (
                    <div className="flex items-center gap-1">
--- a/apps/app/src/components/views/board-view/shared/branch-selector.tsx
+++ b/apps/app/src/components/views/board-view/shared/branch-selector.tsx
@@ -0,0 +1,98 @@
+"use client";
+
+import { Label } from "@/components/ui/label";
+import { BranchAutocomplete } from "@/components/ui/branch-autocomplete";
+import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group";
+import { cn } from "@/lib/utils";
+
+interface BranchSelectorProps {
+  useCurrentBranch: boolean;
+  onUseCurrentBranchChange: (useCurrent: boolean) => void;
+  branchName: string;
+  onBranchNameChange: (branchName: string) => void;
+  branchSuggestions: string[];
+  currentBranch?: string;
+  disabled?: boolean;
+  testIdPrefix?: string;
+}
+
+export function BranchSelector({
+  useCurrentBranch,
+  onUseCurrentBranchChange,
+  branchName,
+  onBranchNameChange,
+  branchSuggestions,
+  currentBranch,
+  disabled = false,
+  testIdPrefix = "branch",
+}: BranchSelectorProps) {
+  // Validate: if "other branch" is selected, branch name is required
+  const isBranchRequired = !useCurrentBranch;
+  const hasError = isBranchRequired && !branchName.trim();
+
+  return (
+    <div className="space-y-2">
+      <Label htmlFor={`${testIdPrefix}-selector`}>Target Branch</Label>
+      <RadioGroup
+        value={useCurrentBranch ? "current" : "other"}
+        onValueChange={(value) => onUseCurrentBranchChange(value === "current")}
+        disabled={disabled}
+        data-testid={`${testIdPrefix}-radio-group`}
+      >
+        <div className="flex items-center space-x-2">
+          <RadioGroupItem value="current" id={`${testIdPrefix}-current`} />
+          <Label
+            htmlFor={`${testIdPrefix}-current`}
+            className="font-normal cursor-pointer"
+          >
+            Use current selected branch
+            {currentBranch && (
+              <span className="text-muted-foreground ml-1">
+                ({currentBranch})
+              </span>
+            )}
+          </Label>
+        </div>
+        <div className="flex items-center space-x-2">
+          <RadioGroupItem value="other" id={`${testIdPrefix}-other`} />
+          <Label
+            htmlFor={`${testIdPrefix}-other`}
+            className="font-normal cursor-pointer"
+          >
+            Other branch
+          </Label>
+        </div>
+      </RadioGroup>
+      {!useCurrentBranch && (
+        <div className="ml-6 space-y-1">
+          <BranchAutocomplete
+            value={branchName}
+            onChange={onBranchNameChange}
+            branches={branchSuggestions}
+            placeholder="Select or create branch..."
+            data-testid={`${testIdPrefix}-input`}
+            disabled={disabled}
+            error={hasError}
+          />
+          {hasError && (
+            <p className="text-xs text-destructive">
+              Branch name is required when "Other branch" is selected.
+            </p>
+          )}
+        </div>
+      )}
+      {disabled ? (
+        <p className="text-xs text-muted-foreground">
+          Branch cannot be changed after work has started.
+        </p>
+      ) : (
+        <p className="text-xs text-muted-foreground">
+          {useCurrentBranch
+            ? "Work will be done in the currently selected branch. A worktree will be created if needed."
+            : "Work will be done in this branch. A worktree will be created if needed."}
+        </p>
+      )}
+    </div>
+  );
+}
+
--- a/apps/app/src/components/views/board-view/shared/index.ts
+++ b/apps/app/src/components/views/board-view/shared/index.ts
@@ -4,3 +4,4 @@ export * from "./thinking-level-selector";
 export * from "./profile-quick-select";
 export * from "./testing-tab-content";
 export * from "./priority-selector";
+export * from "./branch-selector";
--- a/apps/app/src/components/views/board-view/worktree-panel/components/worktree-actions-dropdown.tsx
+++ b/apps/app/src/components/views/board-view/worktree-panel/components/worktree-actions-dropdown.tsx
@@ -170,7 +170,8 @@ export function WorktreeActionsDropdown({
            Commit Changes
          </DropdownMenuItem>
        )}
-        {(worktree.branch !== "main" || worktree.hasChanges) && (
+        {/* Show PR option for non-primary worktrees, or primary worktree with changes */}
+        {(!worktree.isMain || worktree.hasChanges) && (
          <DropdownMenuItem onClick={() => onCreatePR(worktree)} className="text-xs">
            <GitPullRequest className="w-3.5 h-3.5 mr-2" />
            Create Pull Request
--- a/apps/app/src/components/views/board-view/worktree-panel/hooks/use-running-features.ts
+++ b/apps/app/src/components/views/board-view/worktree-panel/hooks/use-running-features.ts
@@ -1,47 +1,35 @@
 "use client";

 import { useCallback } from "react";
-import { pathsEqual } from "@/lib/utils";
 import type { WorktreeInfo, FeatureInfo } from "../types";

 interface UseRunningFeaturesOptions {
-  projectPath: string;
  runningFeatureIds: string[];
  features: FeatureInfo[];
-  getWorktreeKey: (worktree: WorktreeInfo) => string;
 }

 export function useRunningFeatures({
-  projectPath,
  runningFeatureIds,
  features,
-  getWorktreeKey,
 }: UseRunningFeaturesOptions) {
  const hasRunningFeatures = useCallback(
    (worktree: WorktreeInfo) => {
      if (runningFeatureIds.length === 0) return false;

-      const worktreeKey = getWorktreeKey(worktree);
-
      return runningFeatureIds.some((featureId) => {
        const feature = features.find((f) => f.id === featureId);
        if (!feature) return false;

-        if (feature.worktreePath) {
-          if (worktree.isMain) {
-            return pathsEqual(feature.worktreePath, projectPath);
-          }
-          return pathsEqual(feature.worktreePath, worktreeKey);
-        }
-
+        // Match by branchName only (worktreePath is no longer stored)
        if (feature.branchName) {
          return worktree.branch === feature.branchName;
        }

+        // No branch assigned - belongs to main worktree
        return worktree.isMain;
      });
    },
-    [runningFeatureIds, features, projectPath, getWorktreeKey]
+    [runningFeatureIds, features]
  );

  return {
--- a/apps/app/src/components/views/board-view/worktree-panel/hooks/use-worktrees.ts
+++ b/apps/app/src/components/views/board-view/worktree-panel/hooks/use-worktrees.ts
@@ -9,9 +9,10 @@ import type { WorktreeInfo } from "../types";
 interface UseWorktreesOptions {
  projectPath: string;
  refreshTrigger?: number;
+  onRemovedWorktrees?: (removedWorktrees: Array<{ path: string; branch: string }>) => void;
 }

-export function useWorktrees({ projectPath, refreshTrigger = 0 }: UseWorktreesOptions) {
+export function useWorktrees({ projectPath, refreshTrigger = 0, onRemovedWorktrees }: UseWorktreesOptions) {
  const [isLoading, setIsLoading] = useState(false);
  const [worktrees, setWorktrees] = useState<WorktreeInfo[]>([]);

@@ -34,8 +35,11 @@ export function useWorktrees({ projectPath, refreshTrigger = 0 }: UseWorktreesOp
        setWorktrees(result.worktrees);
        setWorktreesInStore(projectPath, result.worktrees);
      }
+      // Return removed worktrees so they can be handled by the caller
+      return result.removedWorktrees;
    } catch (error) {
      console.error("Failed to fetch worktrees:", error);
+      return undefined;
    } finally {
      setIsLoading(false);
    }
@@ -47,9 +51,13 @@ export function useWorktrees({ projectPath, refreshTrigger = 0 }: UseWorktreesOp

  useEffect(() => {
    if (refreshTrigger > 0) {
-      fetchWorktrees();
+      fetchWorktrees().then((removedWorktrees) => {
+        if (removedWorktrees && removedWorktrees.length > 0 && onRemovedWorktrees) {
+          onRemovedWorktrees(removedWorktrees);
+        }
+      });
    }
-  }, [refreshTrigger, fetchWorktrees]);
+  }, [refreshTrigger, fetchWorktrees, onRemovedWorktrees]);

  useEffect(() => {
    if (worktrees.length > 0) {
@@ -59,6 +67,8 @@ export function useWorktrees({ projectPath, refreshTrigger = 0 }: UseWorktreesOp
        : worktrees.some((w) => !w.isMain && pathsEqual(w.path, currentPath));

      if (currentWorktree == null || (currentPath !== null && !currentWorktreeExists)) {
+        // Find the primary worktree and get its branch name
+        // Fallback to "main" only if worktrees haven't loaded yet
        const mainWorktree = worktrees.find((w) => w.isMain);
        const mainBranch = mainWorktree?.branch || "main";
        setCurrentWorktree(projectPath, null, mainBranch);
--- a/apps/app/src/components/views/board-view/worktree-panel/types.ts
+++ b/apps/app/src/components/views/board-view/worktree-panel/types.ts
@@ -22,7 +22,6 @@ export interface DevServerInfo {

 export interface FeatureInfo {
  id: string;
-  worktreePath?: string;
  branchName?: string;
 }

@@ -33,6 +32,7 @@ export interface WorktreePanelProps {
  onCommit: (worktree: WorktreeInfo) => void;
  onCreatePR: (worktree: WorktreeInfo) => void;
  onCreateBranch: (worktree: WorktreeInfo) => void;
+  onRemovedWorktrees?: (removedWorktrees: Array<{ path: string; branch: string }>) => void;
  runningFeatureIds?: string[];
  features?: FeatureInfo[];
  refreshTrigger?: number;
--- a/apps/app/src/components/views/board-view/worktree-panel/worktree-panel.tsx
+++ b/apps/app/src/components/views/board-view/worktree-panel/worktree-panel.tsx
@@ -21,6 +21,7 @@ export function WorktreePanel({
  onCommit,
  onCreatePR,
  onCreateBranch,
+  onRemovedWorktrees,
  runningFeatureIds = [],
  features = [],
  refreshTrigger = 0,
@@ -33,7 +34,7 @@ export function WorktreePanel({
    useWorktreesEnabled,
    fetchWorktrees,
    handleSelectWorktree,
-  } = useWorktrees({ projectPath, refreshTrigger });
+  } = useWorktrees({ projectPath, refreshTrigger, onRemovedWorktrees });

  const {
    isStartingDevServer,
@@ -74,10 +75,8 @@ export function WorktreePanel({
  const { defaultEditorName } = useDefaultEditor();

  const { hasRunningFeatures } = useRunningFeatures({
-    projectPath,
    runningFeatureIds,
    features,
-    getWorktreeKey,
  });

  const isWorktreeSelected = (worktree: WorktreeInfo) => {
@@ -163,7 +162,12 @@ export function WorktreePanel({
          variant="ghost"
          size="sm"
          className="h-7 w-7 p-0 text-muted-foreground hover:text-foreground"
-          onClick={fetchWorktrees}
+          onClick={async () => {
+            const removedWorktrees = await fetchWorktrees();
+            if (removedWorktrees && removedWorktrees.length > 0 && onRemovedWorktrees) {
+              onRemovedWorktrees(removedWorktrees);
+            }
+          }}
          disabled={isLoading}
          title="Refresh worktrees"
        >
--- a/apps/app/src/components/views/context-view.tsx
+++ b/apps/app/src/components/views/context-view.tsx
@@ -213,15 +213,25 @@ export function ContextView() {
        await api.writeFile(filePath, newFileContent);
      }

+      // Close dialog and reset state immediately after successful file write
      setIsAddDialogOpen(false);
      setNewFileName("");
      setNewFileType("text");
      setUploadedImageData(null);
      setNewFileContent("");
      setIsDropHovering(false);
+      
+      // Load files after dialog is closed
      await loadContextFiles();
    } catch (error) {
      console.error("Failed to add file:", error);
+      // Still close the dialog even if loadContextFiles fails
+      setIsAddDialogOpen(false);
+      setNewFileName("");
+      setNewFileType("text");
+      setUploadedImageData(null);
+      setNewFileContent("");
+      setIsDropHovering(false);
    }
  };

--- a/apps/app/src/hooks/use-auto-mode.ts
+++ b/apps/app/src/hooks/use-auto-mode.ts
@@ -13,7 +13,6 @@ export function useAutoMode() {
    setAutoModeRunning,
    addRunningTask,
    removeRunningTask,
-    clearRunningTasks,
    currentProject,
    addAutoModeActivity,
    maxConcurrency,
@@ -24,7 +23,6 @@ export function useAutoMode() {
      setAutoModeRunning: state.setAutoModeRunning,
      addRunningTask: state.addRunningTask,
      removeRunningTask: state.removeRunningTask,
-      clearRunningTasks: state.clearRunningTasks,
      currentProject: state.currentProject,
      addAutoModeActivity: state.addAutoModeActivity,
      maxConcurrency: state.maxConcurrency,
@@ -119,33 +117,6 @@ export function useAutoMode() {
          }
          break;

-        case "auto_mode_stopped":
-          // Auto mode was explicitly stopped (by user or error)
-          setAutoModeRunning(eventProjectId, false);
-          clearRunningTasks(eventProjectId);
-          console.log("[AutoMode] Auto mode stopped");
-          break;
-
-        case "auto_mode_started":
-          // Auto mode started - ensure UI reflects running state
-          console.log("[AutoMode] Auto mode started:", event.message);
-          break;
-
-        case "auto_mode_idle":
-          // Auto mode is running but has no pending features to pick up
-          // This is NOT a stop - auto mode keeps running and will pick up new features
-          console.log("[AutoMode] Auto mode idle - waiting for new features");
-          break;
-
-        case "auto_mode_complete":
-          // Legacy event - only handle if it looks like a stop (for backwards compatibility)
-          if (event.message === "Auto mode stopped") {
-            setAutoModeRunning(eventProjectId, false);
-            clearRunningTasks(eventProjectId);
-            console.log("[AutoMode] Auto mode stopped (legacy event)");
-          }
-          break;
-
        case "auto_mode_error":
          console.error("[AutoMode Error]", event.error);
          if (event.featureId && event.error) {
@@ -218,128 +189,35 @@ export function useAutoMode() {
    projectId,
    addRunningTask,
    removeRunningTask,
-    clearRunningTasks,
    setAutoModeRunning,
    addAutoModeActivity,
    getProjectIdFromPath,
  ]);

-  // Restore auto mode for all projects that were running when app was closed
-  // This runs once on mount to restart auto loops for persisted running states
-  useEffect(() => {
-    const api = getElectronAPI();
-    if (!api?.autoMode) return;
-
-    // Find all projects that have auto mode marked as running
-    const projectsToRestart: Array<{ projectId: string; projectPath: string }> =
-      [];
-    for (const [projectId, state] of Object.entries(autoModeByProject)) {
-      if (state.isRunning) {
-        // Find the project path for this project ID
-        const project = projects.find((p) => p.id === projectId);
-        if (project) {
-          projectsToRestart.push({ projectId, projectPath: project.path });
-        }
-      }
-    }
-
-    // Restart auto mode for each project
-    for (const { projectId, projectPath } of projectsToRestart) {
-      console.log(`[AutoMode] Restoring auto mode for project: ${projectPath}`);
-      api.autoMode
-        .start(projectPath, maxConcurrency)
-        .then((result) => {
-          if (!result.success) {
-            console.error(
-              `[AutoMode] Failed to restore auto mode for ${projectPath}:`,
-              result.error
-            );
-            // Mark as not running if we couldn't restart
-            setAutoModeRunning(projectId, false);
-          } else {
-            console.log(`[AutoMode] Restored auto mode for ${projectPath}`);
-          }
-        })
-        .catch((error) => {
-          console.error(
-            `[AutoMode] Error restoring auto mode for ${projectPath}:`,
-            error
-          );
-          setAutoModeRunning(projectId, false);
-        });
-    }
-    // Only run once on mount - intentionally empty dependency array
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, []);
-
-  // Start auto mode
-  const start = useCallback(async () => {
+  // Start auto mode - UI only, feature pickup is handled in board-view.tsx
+  const start = useCallback(() => {
    if (!currentProject) {
      console.error("No project selected");
      return;
    }

-    try {
-      const api = getElectronAPI();
-      if (!api?.autoMode) {
-        throw new Error("Auto mode API not available");
-      }
-
-      const result = await api.autoMode.start(
-        currentProject.path,
-        maxConcurrency
-      );
-
-      if (result.success) {
-        setAutoModeRunning(currentProject.id, true);
-        console.log(
-          `[AutoMode] Started successfully with maxConcurrency: ${maxConcurrency}`
-        );
-      } else {
-        console.error("[AutoMode] Failed to start:", result.error);
-        throw new Error(result.error || "Failed to start auto mode");
-      }
-    } catch (error) {
-      console.error("[AutoMode] Error starting:", error);
-      if (currentProject) {
-        setAutoModeRunning(currentProject.id, false);
-      }
-      throw error;
-    }
+    setAutoModeRunning(currentProject.id, true);
+    console.log(`[AutoMode] Started with maxConcurrency: ${maxConcurrency}`);
  }, [currentProject, setAutoModeRunning, maxConcurrency]);

-  // Stop auto mode - only turns off the toggle, running tasks continue
-  const stop = useCallback(async () => {
+  // Stop auto mode - UI only, running tasks continue until natural completion
+  const stop = useCallback(() => {
    if (!currentProject) {
      console.error("No project selected");
      return;
    }

-    try {
-      const api = getElectronAPI();
-      if (!api?.autoMode) {
-        throw new Error("Auto mode API not available");
-      }
-
-      const result = await api.autoMode.stop(currentProject.path);
-
-      if (result.success) {
-        setAutoModeRunning(currentProject.id, false);
-        // NOTE: We intentionally do NOT clear running tasks here.
-        // Stopping auto mode only turns off the toggle to prevent new features
-        // from being picked up. Running tasks will complete naturally and be
-        // removed via the auto_mode_feature_complete event.
-        console.log(
-          "[AutoMode] Stopped successfully - running tasks will continue"
-        );
-      } else {
-        console.error("[AutoMode] Failed to stop:", result.error);
-        throw new Error(result.error || "Failed to stop auto mode");
-      }
-    } catch (error) {
-      console.error("[AutoMode] Error stopping:", error);
-      throw error;
-    }
+    setAutoModeRunning(currentProject.id, false);
+    // NOTE: We intentionally do NOT clear running tasks here.
+    // Stopping auto mode only turns off the toggle to prevent new features
+    // from being picked up. Running tasks will complete naturally and be
+    // removed via the auto_mode_feature_complete event.
+    console.log("[AutoMode] Stopped - running tasks will continue");
  }, [currentProject, setAutoModeRunning]);

  // Stop a specific feature
--- a/apps/app/src/lib/electron.ts
+++ b/apps/app/src/lib/electron.ts
@@ -80,7 +80,6 @@ export interface RunningAgentsResult {
  success: boolean;
  runningAgents?: RunningAgent[];
  totalCount?: number;
-  autoLoopRunning?: boolean;
  error?: string;
 }

@@ -217,7 +216,6 @@ export interface AutoModeAPI {
  status: (projectPath?: string) => Promise<{
    success: boolean;
    isRunning?: boolean;
-    autoLoopRunning?: boolean; // Backend uses this name instead of isRunning
    currentFeatureId?: string | null;
    runningFeatures?: string[];
    runningProjects?: string[];
@@ -1442,7 +1440,6 @@ function createMockAutoModeAPI(): AutoModeAPI {
      return {
        success: true,
        isRunning: mockAutoModeRunning,
-        autoLoopRunning: mockAutoModeRunning,
        currentFeatureId: mockAutoModeRunning ? "feature-0" : null,
        runningFeatures: Array.from(mockRunningFeatures),
        runningCount: mockRunningFeatures.size,
@@ -2593,7 +2590,6 @@ function createMockRunningAgentsAPI(): RunningAgentsAPI {
        success: true,
        runningAgents,
        totalCount: runningAgents.length,
-        autoLoopRunning: mockAutoModeRunning,
      };
    },
  };
--- a/apps/app/src/lib/http-api-client.ts
+++ b/apps/app/src/lib/http-api-client.ts
@@ -738,7 +738,6 @@ export class HttpApiClient implements ElectronAPI {
        isAutoMode: boolean;
      }>;
      totalCount?: number;
-      autoLoopRunning?: boolean;
      error?: string;
    }> => this.get("/api/running-agents"),
  };
--- a/apps/app/src/store/app-store.ts
+++ b/apps/app/src/store/app-store.ts
@@ -296,9 +296,8 @@ export interface Feature {
  error?: string; // Error message if the agent errored during processing
  priority?: number; // Priority: 1 = high, 2 = medium, 3 = low
  dependencies?: string[]; // Array of feature IDs this feature depends on
-  // Worktree info - set when a feature is being worked on in an isolated git worktree
-  worktreePath?: string; // Path to the worktree directory
-  branchName?: string; // Name of the feature branch
+  // Branch info - worktree path is derived at runtime from branchName
+  branchName?: string; // Name of the feature branch (undefined = use current worktree)
  justFinishedAt?: string; // ISO timestamp when agent just finished and moved to waiting_approval (shows badge for 2 minutes)
 }

@@ -404,7 +403,10 @@ export interface AppState {

  // User-managed Worktrees (per-project)
  // projectPath -> { path: worktreePath or null for main, branch: branch name }
-  currentWorktreeByProject: Record<string, { path: string | null; branch: string }>;
+  currentWorktreeByProject: Record<
+    string,
+    { path: string | null; branch: string }
+  >;
  worktreesByProject: Record<
    string,
    Array<{
@@ -588,7 +590,11 @@ export interface AppActions {

  // Worktree Settings actions
  setUseWorktrees: (enabled: boolean) => void;
-  setCurrentWorktree: (projectPath: string, worktreePath: string | null, branch: string) => void;
+  setCurrentWorktree: (
+    projectPath: string,
+    worktreePath: string | null,
+    branch: string
+  ) => void;
  setWorktrees: (
    projectPath: string,
    worktrees: Array<{
@@ -599,7 +605,9 @@ export interface AppActions {
      changedFilesCount?: number;
    }>
  ) => void;
-  getCurrentWorktree: (projectPath: string) => { path: string | null; branch: string } | null;
+  getCurrentWorktree: (
+    projectPath: string
+  ) => { path: string | null; branch: string } | null;
  getWorktrees: (projectPath: string) => Array<{
    path: string;
    branch: string;
@@ -607,6 +615,8 @@ export interface AppActions {
    hasChanges?: boolean;
    changedFilesCount?: number;
  }>;
+  isPrimaryWorktreeBranch: (projectPath: string, branchName: string) => boolean;
+  getPrimaryWorktreeBranch: (projectPath: string) => string | null;

  // Profile Display Settings actions
  setShowProfilesOnly: (enabled: boolean) => void;
@@ -1347,7 +1357,8 @@ export const useAppStore = create<AppState & AppActions>()(

      // Feature Default Settings actions
      setDefaultSkipTests: (skip) => set({ defaultSkipTests: skip }),
-      setEnableDependencyBlocking: (enabled) => set({ enableDependencyBlocking: enabled }),
+      setEnableDependencyBlocking: (enabled) =>
+        set({ enableDependencyBlocking: enabled }),

      // Worktree Settings actions
      setUseWorktrees: (enabled) => set({ useWorktrees: enabled }),
@@ -1380,6 +1391,18 @@ export const useAppStore = create<AppState & AppActions>()(
        return get().worktreesByProject[projectPath] ?? [];
      },

+      isPrimaryWorktreeBranch: (projectPath, branchName) => {
+        const worktrees = get().worktreesByProject[projectPath] ?? [];
+        const primary = worktrees.find((w) => w.isMain);
+        return primary?.branch === branchName;
+      },
+
+      getPrimaryWorktreeBranch: (projectPath) => {
+        const worktrees = get().worktreesByProject[projectPath] ?? [];
+        const primary = worktrees.find((w) => w.isMain);
+        return primary?.branch ?? null;
+      },
+
      // Profile Display Settings actions
      setShowProfilesOnly: (enabled) => set({ showProfilesOnly: enabled }),

@@ -2237,7 +2260,8 @@ export const useAppStore = create<AppState & AppActions>()(
        // Settings
        apiKeys: state.apiKeys,
        maxConcurrency: state.maxConcurrency,
-        autoModeByProject: state.autoModeByProject,
+        // Note: autoModeByProject is intentionally NOT persisted
+        // Auto-mode should always default to OFF on app refresh
        defaultSkipTests: state.defaultSkipTests,
        enableDependencyBlocking: state.enableDependencyBlocking,
        useWorktrees: state.useWorktrees,
--- a/apps/app/src/types/electron.d.ts
+++ b/apps/app/src/types/electron.d.ts
@@ -198,30 +198,6 @@ export type AutoModeEvent =
      projectId?: string;
      projectPath?: string;
    }
-  | {
-      type: "auto_mode_complete";
-      message: string;
-      projectId?: string;
-      projectPath?: string;
-    }
-  | {
-      type: "auto_mode_stopped";
-      message: string;
-      projectId?: string;
-      projectPath?: string;
-    }
-  | {
-      type: "auto_mode_started";
-      message: string;
-      projectId?: string;
-      projectPath?: string;
-    }
-  | {
-      type: "auto_mode_idle";
-      message: string;
-      projectId?: string;
-      projectPath?: string;
-    }
  | {
      type: "auto_mode_phase";
      featureId: string;
@@ -310,20 +286,6 @@ export interface SpecRegenerationAPI {
 }

 export interface AutoModeAPI {
-  start: (
-    projectPath: string,
-    maxConcurrency?: number
-  ) => Promise<{
-    success: boolean;
-    error?: string;
-  }>;
-
-  stop: (projectPath: string) => Promise<{
-    success: boolean;
-    error?: string;
-    runningFeatures?: number;
-  }>;
-
  stopFeature: (featureId: string) => Promise<{
    success: boolean;
    error?: string;
@@ -331,7 +293,6 @@ export interface AutoModeAPI {

  status: (projectPath?: string) => Promise<{
    success: boolean;
-    autoLoopRunning?: boolean;
    isRunning?: boolean;
    currentFeatureId?: string | null;
    runningFeatures?: string[];
@@ -343,8 +304,7 @@ export interface AutoModeAPI {
  runFeature: (
    projectPath: string,
    featureId: string,
-    useWorktrees?: boolean,
-    worktreePath?: string
+    useWorktrees?: boolean
  ) => Promise<{
    success: boolean;
    passes?: boolean;
@@ -390,7 +350,7 @@ export interface AutoModeAPI {
    featureId: string,
    prompt: string,
    imagePaths?: string[],
-    worktreePath?: string
+    useWorktrees?: boolean
  ) => Promise<{
    success: boolean;
    passes?: boolean;
@@ -632,6 +592,10 @@ export interface WorktreeAPI {
      hasChanges?: boolean;
      changedFilesCount?: number;
    }>;
+    removedWorktrees?: Array<{
+      path: string;
+      branch: string;
+    }>;
    error?: string;
  }>;