fix: import existing worktrees including main worktree on project add

- Fix worktree import for existing projects (duplicate check was skipping import)
- Import the main worktree alongside linked worktrees
- Add isMainWorktree flag to branch data, derived from path comparison
- Block deletion of main worktree branches in backend
- Hide delete menu on main worktree branch cards in UI
- Show "main worktree" badge to distinguish from linked worktrees
- Canonicalize paths for reliable comparison on macOS
- Fetch branches from backend after project creation for immediate UI update

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Kvadratni

staged/src-tauri/src/lib.rs

@@ -56,6 +56,7 @@ pub struct BranchWithWorkdir {
     pub base_branch: String,
     pub pr_number: Option<u64>,
     pub worktree_path: Option<String>,
+    pub is_main_worktree: bool,
     pub created_at: i64,
     pub updated_at: i64,
 }
@@ -402,74 +403,72 @@ fn list_projects(
 }
 
 /// Import existing worktrees for a project.
-/// 
+///
 /// Scans the repository for existing worktrees and creates Branch + Workdir
 /// records for each one. Skips the main worktree (the repo itself).
-/// 
+///
 /// Returns the number of worktrees imported.
 fn import_existing_worktrees(
     store: &Arc<Store>,
     project: &store::Project,
 ) -> Result<usize, String> {
     let repo_path = Path::new(&project.repo_path);
-    
-    // Get the default branch to use as base for imported branches
+
     let default_branch = git::detect_default_branch(repo_path)
-        .map_err(|e| format!("Failed to detect default branch: {}", e))?;
-    
-    // List all worktrees in the repository
-    let worktrees = git::list_worktrees(repo_path)
-        .map_err(|e| format!("Failed to list worktrees: {}", e))?;
-    
+        .map_err(|e| format!("Failed to detect default branch: {e}"))?;
+
+    let worktrees =
+        git::list_worktrees(repo_path).map_err(|e| format!("Failed to list worktrees: {e}"))?;
+
     let mut imported_count = 0;
-    
+
     for (worktree_path, branch_name) in worktrees {
-        // Skip the main worktree (the repo itself)
-        if worktree_path == repo_path {
-            continue;
-        }
-        
-        // Skip worktrees without a branch (detached HEAD)
         let branch_name = match branch_name {
             Some(name) => name,
             None => {
-                log::debug!("Skipping worktree at {} (detached HEAD)", worktree_path.display());
+                log::debug!(
+                    "Skipping worktree at {} (detached HEAD)",
+                    worktree_path.display()
+                );
                 continue;
             }
         };
-        
-        // Check if we already have a branch with this name
+
         let existing_branches = store
             .list_branches_for_project(&project.id)
             .map_err(|e| e.to_string())?;
-        
-        if existing_branches.iter().any(|b| b.branch_name == branch_name) {
-            log::debug!("Branch '{}' already exists, skipping import", branch_name);
+
+        if existing_branches
+            .iter()
+            .any(|b| b.branch_name == branch_name)
+        {
+            log::debug!("Branch '{branch_name}' already exists, skipping import");
             continue;
         }
-        
-        // Create a Branch record
+
         let branch = store::Branch::new(&project.id, &branch_name, &default_branch);
-        store.create_branch(&branch).map_err(|e| {
-            format!("Failed to create branch '{}': {}", branch_name, e)
-        })?;
-        
-        // Create a Workdir record linked to this branch
+        store
+            .create_branch(&branch)
+            .map_err(|e| format!("Failed to create branch '{branch_name}': {e}"))?;
+
         let worktree_str = worktree_path
             .to_str()
             .ok_or_else(|| format!("Invalid worktree path: {}", worktree_path.display()))?;
-        
-        let workdir = store::Workdir::new(&project.id, worktree_str)
-            .with_branch(&branch.id);
-        
-        store.create_workdir(&workdir).map_err(|e| {
-            format!("Failed to create workdir for '{}': {}", branch_name, e)
-        })?;
-        
-        log::info!("Imported existing worktree: {} -> {}", branch_name, worktree_path.display());
+
+        let workdir = store::Workdir::new(&project.id, worktree_str).with_branch(&branch.id);
+
+        store
+            .create_workdir(&workdir)
+            .map_err(|e| format!("Failed to create workdir for '{branch_name}': {e}"))?;
+
+        log::info!(
+            "Imported worktree: {} -> {}",
+            branch_name,
+            worktree_path.display()
+        );
         imported_count += 1;
     }
-    
+
     Ok(imported_count)
 }
 
@@ -484,14 +483,27 @@ fn create_project(
     // Validate that the path is a git repo
     let path = Path::new(&repo_path);
     if !path.join(".git").exists() && !path.is_dir() {
-        return Err(format!("Not a git repository: {}", repo_path));
+        return Err(format!("Not a git repository: {repo_path}"));
     }
 
-    // Check for duplicate
+    // Check for duplicate — still import worktrees even for existing projects,
+    // since they may have been added before this feature existed.
     if let Some(existing) = store
         .get_project_by_repo(&repo_path)
         .map_err(|e| e.to_string())?
     {
+        match import_existing_worktrees(&store, &existing) {
+            Ok(count) if count > 0 => {
+                log::info!(
+                    "Imported {count} worktree(s) for existing project '{}'",
+                    existing.repo_path
+                );
+            }
+            Err(e) => {
+                log::warn!("Failed to import worktrees for existing project: {e}");
+            }
+            _ => {}
+        }
         return Ok(existing);
     }
 
@@ -500,20 +512,23 @@ fn create_project(
         project = project.with_subpath(sub);
     }
     store.create_project(&project).map_err(|e| e.to_string())?;
-    
+
     // Import any existing worktrees for this project
     match import_existing_worktrees(&store, &project) {
         Ok(count) => {
             if count > 0 {
-                log::info!("Imported {} existing worktree(s) for project '{}'", count, project.repo_path);
+                log::info!(
+                    "Imported {count} existing worktree(s) for project '{}'",
+                    project.repo_path
+                );
             }
         }
         Err(e) => {
             // Log the error but don't fail project creation
-            log::warn!("Failed to import existing worktrees: {}", e);
+            log::warn!("Failed to import existing worktrees: {e}");
         }
     }
-    
+
     Ok(project)
 }
 
@@ -537,6 +552,15 @@ fn list_branches_for_project(
     project_id: String,
 ) -> Result<Vec<BranchWithWorkdir>, String> {
     let store = get_store(&store)?;
+    let project = store
+        .get_project(&project_id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("Project not found: {project_id}"))?;
+
+    let canonical_repo = Path::new(&project.repo_path)
+        .canonicalize()
+        .unwrap_or_else(|_| PathBuf::from(&project.repo_path));
+
     let branches = store
         .list_branches_for_project(&project_id)
         .map_err(|e| e.to_string())?;
@@ -547,13 +571,21 @@ fn list_branches_for_project(
             .get_workdir_for_branch(&branch.id)
             .map_err(|e| e.to_string())?;
 
+        let is_main = workdir.as_ref().is_some_and(|w| {
+            Path::new(&w.path)
+                .canonicalize()
+                .unwrap_or_else(|_| PathBuf::from(&w.path))
+                == canonical_repo
+        });
+
         result.push(BranchWithWorkdir {
             id: branch.id,
             project_id: branch.project_id,
             branch_name: branch.branch_name,
             base_branch: branch.base_branch,
             pr_number: branch.pr_number,
             worktree_path: workdir.map(|w| w.path),
+            is_main_worktree: is_main,
             created_at: branch.created_at,
             updated_at: branch.updated_at,
         });
@@ -574,7 +606,7 @@ fn create_branch(
     let project = store
         .get_project(&project_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("Project not found: {}", project_id))?;
+        .ok_or_else(|| format!("Project not found: {project_id}"))?;
 
     let repo_path = Path::new(&project.repo_path);
 
@@ -608,6 +640,7 @@ fn create_branch(
         base_branch: branch.base_branch,
         pr_number: branch.pr_number,
         worktree_path: Some(worktree_str),
+        is_main_worktree: false,
         created_at: branch.created_at,
         updated_at: branch.updated_at,
     })
@@ -624,19 +657,31 @@ fn delete_branch(
     let branch = store
         .get_branch(&branch_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("Branch not found: {}", branch_id))?;
+        .ok_or_else(|| format!("Branch not found: {branch_id}"))?;
 
     // Get the project for the repo path
     let project = store
         .get_project(&branch.project_id)
         .map_err(|e| e.to_string())?
         .ok_or_else(|| format!("Project not found: {}", branch.project_id))?;
 
-    // Get the workdir (if any) so we can remove the worktree
     let workdir = store
         .get_workdir_for_branch(&branch_id)
         .map_err(|e| e.to_string())?;
 
+    // Prevent deletion of the main worktree (the repo checkout itself)
+    if let Some(ref wd) = workdir {
+        let canonical_repo = Path::new(&project.repo_path)
+            .canonicalize()
+            .unwrap_or_else(|_| PathBuf::from(&project.repo_path));
+        let canonical_wd = Path::new(&wd.path)
+            .canonicalize()
+            .unwrap_or_else(|_| PathBuf::from(&wd.path));
+        if canonical_wd == canonical_repo {
+            return Err("Cannot delete the main worktree".to_string());
+        }
+    }
+
     if let Some(ref wd) = workdir {
         let repo_path = Path::new(&project.repo_path);
         let worktree_path = Path::new(&wd.path);
@@ -664,7 +709,7 @@ fn delete_note(
     let note = store
         .get_note(&note_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("Note not found: {}", note_id))?;
+        .ok_or_else(|| format!("Note not found: {note_id}"))?;
 
     store.delete_note(&note_id).map_err(|e| e.to_string())?;
 
@@ -694,7 +739,7 @@ fn delete_commit(
     let workdir = store
         .get_workdir_for_branch(&branch_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("No worktree for branch: {}", branch_id))?;
+        .ok_or_else(|| format!("No worktree for branch: {branch_id}"))?;
 
     let worktree = Path::new(&workdir.path);
 
@@ -744,7 +789,7 @@ fn get_branch_timeline(
     let branch = store
         .get_branch(&branch_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("Branch not found: {}", branch_id))?;
+        .ok_or_else(|| format!("Branch not found: {branch_id}"))?;
 
     let workdir = store
         .get_workdir_for_branch(&branch_id)
@@ -877,12 +922,12 @@ fn resolve_branch_context(
     let branch = store
         .get_branch(branch_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("Branch not found: {}", branch_id))?;
+        .ok_or_else(|| format!("Branch not found: {branch_id}"))?;
 
     let workdir = store
         .get_workdir_for_branch(branch_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("No worktree for branch: {}", branch_id))?;
+        .ok_or_else(|| format!("No worktree for branch: {branch_id}"))?;
 
     Ok(BranchDiffContext {
         worktree_path: workdir.path,
@@ -1017,7 +1062,7 @@ async fn ensure_review(
 ) -> Result<store::Review, String> {
     let store = get_store(&store)?;
     let review_scope =
-        store::ReviewScope::parse(&scope).ok_or_else(|| format!("Invalid scope: {}", scope))?;
+        store::ReviewScope::parse(&scope).ok_or_else(|| format!("Invalid scope: {scope}"))?;
 
     store
         .ensure_review(&branch_id, &commit_sha, review_scope)

staged/src-tauri/src/session_commands.rs

@@ -131,7 +131,7 @@ pub fn resume_session(
     let session = store
         .get_session(&session_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("Session not found: {}", session_id))?;
+        .ok_or_else(|| format!("Session not found: {session_id}"))?;
 
     let agent_session_id = session.agent_id.clone();
 
@@ -248,12 +248,12 @@ pub fn start_branch_session(
     let branch = store
         .get_branch(&branch_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("Branch not found: {}", branch_id))?;
+        .ok_or_else(|| format!("Branch not found: {branch_id}"))?;
 
     let workdir = store
         .get_workdir_for_branch(&branch_id)
         .map_err(|e| e.to_string())?
-        .ok_or_else(|| format!("No worktree for branch: {}", branch_id))?;
+        .ok_or_else(|| format!("No worktree for branch: {branch_id}"))?;
 
     let worktree_path = Path::new(&workdir.path);
 

staged/src/lib/BranchCard.svelte

@@ -39,9 +39,11 @@
 
   let { branch, onDelete }: Props = $props();
 
-  const menuItems: MenuItem[] = [
-    { label: 'Delete Branch', icon: Trash2, danger: true, action: () => onDelete?.() },
-  ];
+  let menuItems = $derived<MenuItem[]>(
+    branch.isMainWorktree
+      ? []
+      : [{ label: 'Delete Branch', icon: Trash2, danger: true, action: () => onDelete?.() }]
+  );
 
   let timeline = $state<BranchTimelineData | null>(null);
   let loading = $state(true);
@@ -239,14 +241,19 @@
     <div class="branch-info">
       <GitBranch size={16} class="branch-icon" />
       <span class="branch-name">{branch.branchName}</span>
+      {#if branch.isMainWorktree}
+        <span class="main-badge">main worktree</span>
+      {/if}
       <span class="branch-separator">›</span>
       <span class="base-branch-name">{formatBaseBranch(branch.baseBranch)}</span>
     </div>
     <div class="header-actions">
       <button class="view-diff-btn" onclick={() => (showBranchDiff = true)} title="View diff">
         <FileDiff size={16} />
       </button>
-      <DropdownMenu items={menuItems} />
+      {#if menuItems.length > 0}
+        <DropdownMenu items={menuItems} />
+      {/if}
     </div>
   </div>
 
@@ -428,6 +435,15 @@
     letter-spacing: -0.01em;
   }
 
+  .main-badge {
+    font-size: var(--size-xs);
+    font-weight: 500;
+    color: var(--text-faint);
+    background-color: var(--bg-hover);
+    padding: 1px 6px;
+    border-radius: 4px;
+  }
+
   .branch-separator {
     color: var(--text-faint);
     font-size: var(--size-md);