sync: tighten home branch fetches and zed launching

Author: nikivdev

docs/pr-edit-watcher.md

@@ -68,7 +68,7 @@ If the frontmatter is missing, Flow may fall back to `~/.flow/pr-edit/.index.jso
 - Finds the open PR for the current branch (fallback: queued commit PR)
 - Creates `~/.flow/pr-edit/<project>-<pr>.md` if missing
 - Ensures the file contains PR frontmatter
-- Opens the file in Zed Preview
+- Opens the file in Zed
 - Starts a foreground watcher that syncs on save (Ctrl-C to stop)
 
 ## Status JSON

src/commit.rs

@@ -9606,7 +9606,7 @@ pub fn run_pr(opts: PrOpts) -> Result<()> {
         // Convenience: `f pr open` opens the PR for the current branch (or queued commit) without
         // creating a new commit.
         [a] if a == "open" => return run_pr_open(&repo_root, &opts),
-        // Convenience: `f pr open edit` opens a local markdown file in Zed Preview and syncs PR
+        // Convenience: `f pr open edit` opens a local markdown file in Zed and syncs PR
         // title/body on save.
         [a, b] if a == "open" && b == "edit" => return run_pr_open_edit(&repo_root, &opts),
         _ => {}
@@ -11594,17 +11594,20 @@ fn flow_project_name(repo_root: &Path) -> String {
 }
 
 fn open_in_zed_preview(path: &Path) -> Result<()> {
-    // Prefer Zed Preview if installed, otherwise fall back to Zed.
+    // Prefer the local Zed.app fork and fall back to Preview if that app is not installed.
     let try_open = |app: &str| -> Result<()> {
-        Command::new("open")
+        let status = Command::new("open")
             .args(["-a", app])
             .arg(path)
             .status()
             .with_context(|| format!("failed to open {app}"))?;
+        if !status.success() {
+            bail!("{app} exited with status {status}");
+        }
         Ok(())
     };
 
-    try_open("/Applications/Zed Preview.app").or_else(|_| try_open("/Applications/Zed.app"))
+    try_open("/Applications/Zed.app").or_else(|_| try_open("/Applications/Zed Preview.app"))
 }
 
 fn parse_pr_edit_markdown(text: &str) -> Result<(String, String)> {

src/repos.rs

@@ -70,12 +70,19 @@ pub fn clone_git_like(opts: CloneOpts) -> Result<()> {
 }
 
 fn open_in_zed(path: &std::path::Path) -> Result<()> {
-    std::process::Command::new("open")
-        .args(["-a", "/Applications/Zed Preview.app"])
-        .arg(path)
-        .status()
-        .context("failed to open Zed")?;
-    Ok(())
+    let try_open = |app: &str| -> Result<()> {
+        let status = std::process::Command::new("open")
+            .args(["-a", app])
+            .arg(path)
+            .status()
+            .with_context(|| format!("failed to open {app}"))?;
+        if !status.success() {
+            bail!("{app} exited with status {status}");
+        }
+        Ok(())
+    };
+
+    try_open("/Applications/Zed.app").or_else(|_| try_open("/Applications/Zed Preview.app"))
 }
 
 /// Fuzzy search through repos in ~/repos and print the selected path.

src/sync.rs

@@ -248,6 +248,31 @@ fn resolve_home_branch_sync_target(
     })
 }
 
+fn origin_fetch_branches_for_jj_sync(
+    current_branch: &str,
+    origin_default_branch: Option<&str>,
+    home_branch_sync_target: Option<&HomeBranchSyncTarget>,
+) -> Vec<String> {
+    let mut branches = Vec::new();
+
+    if home_branch_sync_target.is_none() {
+        let current_branch = current_branch.trim();
+        if !current_branch.is_empty() {
+            branches.push(current_branch.to_string());
+        }
+    }
+
+    if let Some(default_branch) = origin_default_branch
+        .map(str::trim)
+        .filter(|branch| !branch.is_empty())
+        && !branches.iter().any(|branch| branch == default_branch)
+    {
+        branches.push(default_branch.to_string());
+    }
+
+    branches
+}
+
 fn select_jj_sync_branch(
     git_head_ref: &str,
     current_bookmarks: &[String],
@@ -2629,46 +2654,23 @@ fn run_jj_sync(
         let mut failures: Vec<String> = Vec::new();
 
         if has_origin && origin_reachable {
-            track_remote_ref(&mut tracked_refs, repo_root, "origin", &current_branch);
-            recorder.record(
-                "jj",
-                format!("jj git fetch --remote origin --branch {}", current_branch),
-            );
-            if let Err(err) = jj_run_in(
-                repo_root,
-                &[
-                    "--quiet",
-                    "git",
-                    "fetch",
-                    "--remote",
-                    "origin",
-                    "--branch",
-                    &current_branch,
-                ],
+            for branch in origin_fetch_branches_for_jj_sync(
+                &current_branch,
+                origin_default_branch.as_deref(),
+                home_branch_sync_target.as_ref(),
             ) {
-                failures.push(format!("origin: {}", err));
-            } else {
-                fetched_any = true;
-            }
-            if let Some(default_branch) = origin_default_branch.as_deref() {
-                track_remote_ref(&mut tracked_refs, repo_root, "origin", default_branch);
+                track_remote_ref(&mut tracked_refs, repo_root, "origin", &branch);
                 recorder.record(
                     "jj",
-                    format!("jj git fetch --remote origin --branch {}", default_branch),
+                    format!("jj git fetch --remote origin --branch {}", branch),
                 );
                 if let Err(err) = jj_run_in(
                     repo_root,
                     &[
-                        "--quiet",
-                        "git",
-                        "fetch",
-                        "--remote",
-                        "origin",
-                        "--branch",
-                        default_branch,
+                        "--quiet", "git", "fetch", "--remote", "origin", "--branch", &branch,
                     ],
                 ) {
-                    failures.push(format!("origin default {}: {}", default_branch, err));
+                    failures.push(format!("origin {}: {}", branch, err));
                 } else {
                     fetched_any = true;
                 }
@@ -5034,6 +5036,31 @@ mod tests {
         assert!(!home_branch_mode_active("nikiv", None));
     }
 
+    #[test]
+    fn origin_fetch_branches_for_home_branch_mode_skips_local_home_branch() {
+        let home_target = HomeBranchSyncTarget {
+            home_branch: "nikiv".to_string(),
+            origin_default_branch: "main".to_string(),
+        };
+
+        assert_eq!(
+            origin_fetch_branches_for_jj_sync("nikiv", Some("main"), Some(&home_target)),
+            vec!["main".to_string()]
+        );
+    }
+
+    #[test]
+    fn origin_fetch_branches_for_regular_sync_dedupes_branches() {
+        assert_eq!(
+            origin_fetch_branches_for_jj_sync("feature/demo", Some("main"), None),
+            vec!["feature/demo".to_string(), "main".to_string()]
+        );
+        assert_eq!(
+            origin_fetch_branches_for_jj_sync("main", Some("main"), None),
+            vec!["main".to_string()]
+        );
+    }
+
     #[test]
     fn resolve_home_branch_sync_target_uses_origin_default_for_home_branch() {
         let dir = tempdir().expect("tempdir");