diff --git a/apps/staged/src-tauri/src/branches.rs b/apps/staged/src-tauri/src/branches.rs
index bd4f1749..94ef5cca 100644
--- a/apps/staged/src-tauri/src/branches.rs
+++ b/apps/staged/src-tauri/src/branches.rs
@@ -809,10 +809,22 @@ pub async fn setup_worktree(
         )
         .map_err(|e| e.to_string())?
     } else {
+        // If the branch exists on the remote (e.g. from an existing PR),
+        // start the new local branch from the remote tracking ref so it
+        // includes the PR's commits. Otherwise fall back to base_branch
+        // for genuinely new branches.
+        let remote_ref = format!("origin/{}", branch.branch_name);
+        let start_point = if git::remote_branch_exists(&repo_path, &branch.branch_name)
+            .map_err(|e| e.to_string())?
+        {
+            &remote_ref
+        } else {
+            &branch.base_branch
+        };
         match create_worktree_with_fallback(
             &repo_path,
             &branch.branch_name,
-            &branch.base_branch,
+            start_point,
             &desired_worktree_path,
         ) {
             Ok(path) => path,
@@ -1530,10 +1542,22 @@ pub(crate) fn setup_worktree_sync(store: &Arc<Store>, branch_id: &str) -> Result
         )
         .map_err(|e| e.to_string())?
     } else {
+        // If the branch exists on the remote (e.g. from an existing PR),
+        // start the new local branch from the remote tracking ref so it
+        // includes the PR's commits. Otherwise fall back to base_branch
+        // for genuinely new branches.
+        let remote_ref = format!("origin/{}", branch.branch_name);
+        let start_point = if crate::git::remote_branch_exists(&repo_path, &branch.branch_name)
+            .map_err(|e| e.to_string())?
+        {
+            &remote_ref
+        } else {
+            &branch.base_branch
+        };
         match crate::git::create_worktree_at_path(
             &repo_path,
             &branch.branch_name,
-            &branch.base_branch,
+            start_point,
             &desired_worktree_path,
         ) {
             Ok(path) => path,
diff --git a/apps/staged/src-tauri/src/git/mod.rs b/apps/staged/src-tauri/src/git/mod.rs
index bc2d1076..a9f65f18 100644
--- a/apps/staged/src-tauri/src/git/mod.rs
+++ b/apps/staged/src-tauri/src/git/mod.rs
@@ -32,6 +32,6 @@ pub use worktree::{
     create_worktree_for_existing_branch_at_path, create_worktree_from_pr,
     create_worktree_from_pr_at_path, get_commits_since_base, get_full_commit_log, get_head_sha,
     get_parent_commit, has_unpushed_commits, list_worktrees, project_worktree_path_for,
-    project_worktree_root_for, remove_worktree, reset_to_commit, switch_branch,
-    update_branch_from_pr, worktree_path_for, CommitInfo, UpdateFromPrResult,
+    project_worktree_root_for, remote_branch_exists, remove_worktree, reset_to_commit,
+    switch_branch, update_branch_from_pr, worktree_path_for, CommitInfo, UpdateFromPrResult,
 };
diff --git a/apps/staged/src-tauri/src/git/worktree.rs b/apps/staged/src-tauri/src/git/worktree.rs
index b0fe43d6..a684a8b6 100644
--- a/apps/staged/src-tauri/src/git/worktree.rs
+++ b/apps/staged/src-tauri/src/git/worktree.rs
@@ -397,6 +397,13 @@ pub fn branch_exists(repo: &Path, branch_name: &str) -> Result<bool, GitError> {
     Ok(result.is_ok())
 }
 
+/// Check whether a remote tracking branch (`origin/<branch_name>`) exists.
+pub fn remote_branch_exists(repo: &Path, branch_name: &str) -> Result<bool, GitError> {
+    let ref_name = format!("refs/remotes/origin/{branch_name}");
+    let result = cli::run(repo, &["rev-parse", "--verify", &ref_name]);
+    Ok(result.is_ok())
+}
+
 /// Reset HEAD to a specific commit (hard reset).
 /// This discards all commits after the specified commit.
 pub fn reset_to_commit(worktree: &Path, commit_sha: &str) -> Result<(), GitError> {
diff --git a/apps/staged/src-tauri/src/lib.rs b/apps/staged/src-tauri/src/lib.rs
index 18b8c589..338d165d 100644
--- a/apps/staged/src-tauri/src/lib.rs
+++ b/apps/staged/src-tauri/src/lib.rs
@@ -218,6 +218,7 @@ fn list_projects(
         .map_err(|e| e.to_string())
 }
 
+#[allow(clippy::too_many_arguments)]
 #[tauri::command(rename_all = "camelCase")]
 fn create_project(
     store: tauri::State<'_, Mutex<Option<Arc<Store>>>>,
@@ -226,6 +227,8 @@ fn create_project(
     github_repo: Option<String>,
     location: Option<String>,
     subpath: Option<String>,
+    branch_name: Option<String>,
+    pr_number: Option<u64>,
 ) -> Result<store::Project, String> {
     let store = get_store(&store)?;
     let trimmed = name.trim();
@@ -243,7 +246,12 @@ fn create_project(
         Some("remote") => store::ProjectLocation::Remote,
         _ => store::ProjectLocation::Local,
     };
-    let inferred_branch_name = branches::infer_branch_name(trimmed);
+    let inferred_branch_name = branch_name
+        .as_deref()
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .map(ToOwned::to_owned)
+        .unwrap_or_else(|| branches::infer_branch_name(trimmed));
     let mut project = store::Project::named(trimmed);
     project.location = project_location;
     if let Some(repo) = github_repo.clone() {
@@ -292,21 +300,27 @@ fn create_project(
 
         let branch_id = match project.location {
             store::ProjectLocation::Local => {
-                let branch =
+                let mut branch =
                     store::Branch::new(&project.id, &inferred_branch_name, &effective_base)
                         .with_project_repo(&project_repo.id);
+                if let Some(pr) = pr_number {
+                    branch = branch.with_pr(pr);
+                }
                 store.create_branch(&branch).map_err(|e| e.to_string())?;
                 Some(branch.id)
             }
             store::ProjectLocation::Remote => {
                 let workspace_name = branches::infer_workspace_name(&inferred_branch_name);
-                let branch = store::Branch::new_remote(
+                let mut branch = store::Branch::new_remote(
                     &project.id,
                     &inferred_branch_name,
                     &effective_base,
                     &workspace_name,
                 )
                 .with_project_repo(&project_repo.id);
+                if let Some(pr) = pr_number {
+                    branch = branch.with_pr(pr);
+                }
                 store.create_branch(&branch).map_err(|e| e.to_string())?;
                 log::info!(
                     "[create_project] created remote branch={} workspace={} status=starting project={}",
@@ -401,6 +415,7 @@ fn list_recent_repos(
         .map_err(|e| e.to_string())
 }
 
+#[allow(clippy::too_many_arguments)]
 #[tauri::command(rename_all = "camelCase")]
 async fn add_project_repo(
     store: tauri::State<'_, Mutex<Option<Arc<Store>>>>,
@@ -410,6 +425,7 @@ async fn add_project_repo(
     branch_name: Option<String>,
     subpath: Option<String>,
     set_as_primary: Option<bool>,
+    pr_number: Option<u64>,
 ) -> Result<store::ProjectRepo, String> {
     let store = get_store(&store)?;
     let repo = project_commands::add_project_repo_impl(
@@ -420,6 +436,7 @@ async fn add_project_repo(
         subpath,
         set_as_primary,
         None,
+        pr_number,
     )
     .await?;
 
diff --git a/apps/staged/src-tauri/src/project_commands.rs b/apps/staged/src-tauri/src/project_commands.rs
index 16248f14..3ebb80e5 100644
--- a/apps/staged/src-tauri/src/project_commands.rs
+++ b/apps/staged/src-tauri/src/project_commands.rs
@@ -8,6 +8,7 @@ use crate::{blox, branches, git};
 /// Core logic for adding a GitHub repository to a project.
 ///
 /// Called by both the `add_project_repo` Tauri command and the MCP tool.
+#[allow(clippy::too_many_arguments)]
 pub(crate) async fn add_project_repo_impl(
     store: Arc<Store>,
     project_id: String,
@@ -16,6 +17,7 @@ pub(crate) async fn add_project_repo_impl(
     subpath: Option<String>,
     set_as_primary: Option<bool>,
     reason: Option<String>,
+    pr_number: Option<u64>,
 ) -> Result<store::ProjectRepo, String> {
     let project = store
         .get_project(&project_id)
@@ -121,13 +123,26 @@ pub(crate) async fn add_project_repo_impl(
     };
     let branch = match project.location {
         store::ProjectLocation::Local => {
-            store::Branch::new(&project_id, &repo.branch_name, &effective_base)
-                .with_project_repo(&repo.id)
+            let mut b = store::Branch::new(&project_id, &repo.branch_name, &effective_base)
+                .with_project_repo(&repo.id);
+            if let Some(pr) = pr_number {
+                b = b.with_pr(pr);
+            }
+            b
         }
         store::ProjectLocation::Remote => {
             let ws_name = branches::resolve_project_workspace_name(&store, &project, None)?;
-            store::Branch::new_remote(&project_id, &repo.branch_name, &effective_base, &ws_name)
-                .with_project_repo(&repo.id)
+            let mut b = store::Branch::new_remote(
+                &project_id,
+                &repo.branch_name,
+                &effective_base,
+                &ws_name,
+            )
+            .with_project_repo(&repo.id);
+            if let Some(pr) = pr_number {
+                b = b.with_pr(pr);
+            }
+            b
         }
     };
     store.create_branch(&branch).map_err(|e| e.to_string())?;
diff --git a/apps/staged/src-tauri/src/project_mcp.rs b/apps/staged/src-tauri/src/project_mcp.rs
index 684c9259..a82b0d1d 100644
--- a/apps/staged/src-tauri/src/project_mcp.rs
+++ b/apps/staged/src-tauri/src/project_mcp.rs
@@ -589,6 +589,7 @@ impl ProjectToolsHandler {
             p.subpath,
             None,
             p.reason,
+            None,
         )
         .await
         {
diff --git a/apps/staged/src/lib/commands.ts b/apps/staged/src/lib/commands.ts
index 275c5590..464fb650 100644
--- a/apps/staged/src/lib/commands.ts
+++ b/apps/staged/src/lib/commands.ts
@@ -57,9 +57,18 @@ export function createProject(
   name: string,
   location: 'local' | 'remote',
   githubRepo?: string,
-  subpath?: string
+  subpath?: string,
+  branchName?: string,
+  prNumber?: number
 ): Promise<Project> {
-  return invoke('create_project', { name, location, githubRepo: githubRepo ?? null, subpath });
+  return invoke('create_project', {
+    name,
+    location,
+    githubRepo: githubRepo ?? null,
+    subpath,
+    branchName: branchName ?? null,
+    prNumber: prNumber ?? null,
+  });
 }
 
 export function deleteProject(id: string): Promise<void> {
@@ -79,7 +88,8 @@ export function addProjectRepo(
   githubRepo: string,
   branchName?: string,
   subpath?: string,
-  setAsPrimary?: boolean
+  setAsPrimary?: boolean,
+  prNumber?: number
 ): Promise<ProjectRepo> {
   return invoke('add_project_repo', {
     projectId,
@@ -87,6 +97,7 @@ export function addProjectRepo(
     branchName: branchName ?? null,
     subpath: subpath ?? null,
     setAsPrimary: setAsPrimary ?? null,
+    prNumber: prNumber ?? null,
   });
 }
 
diff --git a/apps/staged/src/lib/features/projects/BranchPicker.svelte b/apps/staged/src/lib/features/projects/BranchPicker.svelte
new file mode 100644
index 00000000..507f9c8f
--- /dev/null
+++ b/apps/staged/src/lib/features/projects/BranchPicker.svelte
@@ -0,0 +1,459 @@
+<!--
+  BranchPicker.svelte - PR or branch picker with search dropdown
+
+  Features:
+  - Fetches PRs and remote branches for the selected repo
+  - Filters by typed query
+  - Selecting a PR uses its head ref as the branch name
+  - Selecting a branch uses its name directly
+-->
+<script lang="ts">
+  import { GitPullRequest, GitBranch } from 'lucide-svelte';
+  import type { PullRequest, BranchRef } from '../../types';
+  import * as commands from '../../api/commands';
+
+  interface PickerItem {
+    kind: 'pr' | 'branch';
+    label: string;
+    branchName: string;
+    detail?: string;
+  }
+
+  export interface BranchSelection {
+    kind: 'pr' | 'branch';
+    branchName: string;
+    /** For PRs this is the PR title; for branches it is the branch name. */
+    label: string;
+  }
+
+  interface Props {
+    value: string;
+    repo: string;
+    disabled?: boolean;
+    isNewBranch?: boolean;
+    /** The PR that matches the current branch value, if any. */
+    matchedPr?: PullRequest | null;
+    /** When set, auto-select this PR after data loads. Cleared after use. */
+    initialPrNumber?: number | null;
+    /** When set, auto-fill this branch name after data loads. Cleared after use. */
+    initialBranchName?: string | null;
+    onSelect?: (selection: BranchSelection) => void;
+  }
+
+  let {
+    value = $bindable(''),
+    repo,
+    disabled = false,
+    isNewBranch = $bindable(false),
+    matchedPr = $bindable(null),
+    initialPrNumber = $bindable(null),
+    initialBranchName = $bindable(null),
+    onSelect,
+  }: Props = $props();
+
+  let pullRequests = $state<PullRequest[]>([]);
+  let branches = $state<BranchRef[]>([]);
+  let loading = $state(false);
+  let showDropdown = $state(false);
+  let highlightedIndex = $state(-1);
+  let inputEl: HTMLInputElement | undefined = $state();
+  /** Generation counter to discard stale async responses when repo changes rapidly. */
+  let fetchGeneration = 0;
+
+  // Fetch PRs and branches when repo changes
+  $effect(() => {
+    if (repo) {
+      fetchData(repo);
+    } else {
+      pullRequests = [];
+      branches = [];
+    }
+  });
+
+  async function fetchData(ghRepo: string) {
+    const gen = ++fetchGeneration;
+    loading = true;
+    try {
+      const [prs, refs] = await Promise.all([
+        commands.listPullRequests(ghRepo).catch(() => [] as PullRequest[]),
+        commands.listGitBranches(ghRepo).catch(() => [] as BranchRef[]),
+      ]);
+      // Discard results if a newer fetch was started while we were waiting
+      if (gen !== fetchGeneration) return;
+      pullRequests = prs;
+      branches = refs;
+
+      // Auto-select a PR if initialPrNumber was provided (e.g. from a pasted PR URL).
+      // Skip focusing the input — the user didn't interact with the picker directly.
+      if (initialPrNumber != null) {
+        const pr = prs.find((p) => p.number === initialPrNumber);
+        if (pr) {
+          selectItem(
+            {
+              kind: 'pr',
+              label: `#${pr.number} ${pr.title}`,
+              branchName: pr.headRef,
+              detail: pr.headRef,
+            },
+            { focus: false }
+          );
+        }
+        initialPrNumber = null;
+      }
+      // Auto-fill a branch name if initialBranchName was provided (e.g. from a pasted branch URL).
+      // Skip focusing the input — the user didn't interact with the picker directly.
+      else if (initialBranchName) {
+        const branchNameToFind = initialBranchName;
+        // Check PRs first — a branch might back a PR
+        const prForBranch = prs.find((p) => p.headRef === branchNameToFind);
+        if (prForBranch) {
+          selectItem(
+            {
+              kind: 'pr',
+              label: `#${prForBranch.number} ${prForBranch.title}`,
+              branchName: prForBranch.headRef,
+              detail: prForBranch.headRef,
+            },
+            { focus: false }
+          );
+        } else {
+          // Check remote branches
+          const refName = refs.find((r) => r.name.replace(/^origin\//, '') === branchNameToFind);
+          if (refName) {
+            selectItem(
+              {
+                kind: 'branch',
+                label: branchNameToFind,
+                branchName: branchNameToFind,
+              },
+              { focus: false }
+            );
+          } else {
+            // Branch not in the list — just set the value (will show as "New branch")
+            value = branchNameToFind;
+            onSelect?.({ kind: 'branch', branchName: branchNameToFind, label: branchNameToFind });
+          }
+        }
+        initialBranchName = null;
+      }
+    } finally {
+      loading = false;
+    }
+  }
+
+  /** All known remote branch names (without origin/ prefix). */
+  let knownBranches = $derived.by((): Set<string> => {
+    const names = new Set<string>();
+    for (const pr of pullRequests) {
+      names.add(pr.headRef);
+    }
+    for (const ref of branches) {
+      names.add(ref.name.replace(/^origin\//, ''));
+    }
+    return names;
+  });
+
+  // Update isNewBranch whenever value or known branches change.
+  // Gate on !loading to avoid a flash of "New branch" while data is being fetched.
+  $effect(() => {
+    const trimmed = value.trim();
+    isNewBranch = trimmed.length > 0 && !loading && !knownBranches.has(trimmed);
+  });
+
+  /** Build a unified list of picker items from PRs and branches. */
+  let allItems = $derived.by((): PickerItem[] => {
+    const items: PickerItem[] = [];
+
+    for (const pr of pullRequests) {
+      items.push({
+        kind: 'pr',
+        label: `#${pr.number} ${pr.title}`,
+        branchName: pr.headRef,
+        detail: pr.headRef,
+      });
+    }
+
+    for (const ref of branches) {
+      // Strip "origin/" prefix for display
+      const name = ref.name.replace(/^origin\//, '');
+      // Skip any refs already covered by PRs (avoids duplicate entries)
+      if (items.some((i) => i.branchName === name)) continue;
+      items.push({
+        kind: 'branch',
+        label: name,
+        branchName: name,
+      });
+    }
+
+    return items;
+  });
+
+  /** Filter items by the current input value. */
+  let filteredItems = $derived.by((): PickerItem[] => {
+    const query = value.trim().toLowerCase();
+    if (!query) return allItems.slice(0, 50);
+    return allItems
+      .filter(
+        (item) =>
+          item.label.toLowerCase().includes(query) || item.branchName.toLowerCase().includes(query)
+      )
+      .slice(0, 50);
+  });
+
+  function handleInput() {
+    highlightedIndex = -1;
+    showDropdown = true;
+    // User is typing freely — clear any previously matched PR
+    matchedPr = null;
+  }
+
+  function handleFocus() {
+    showDropdown = true;
+  }
+
+  function handleBlur() {
+    setTimeout(() => {
+      showDropdown = false;
+    }, 150);
+  }
+
+  function selectItem(item: PickerItem, { focus = true }: { focus?: boolean } = {}) {
+    value = item.branchName;
+    showDropdown = false;
+    highlightedIndex = -1;
+    if (focus) inputEl?.focus();
+
+    // Update matched PR: set when selecting a PR item, clear for branches
+    if (item.kind === 'pr') {
+      matchedPr = pullRequests.find((pr) => pr.headRef === item.branchName) ?? null;
+    } else {
+      matchedPr = null;
+    }
+
+    // For PRs, pass the PR title (strip the "#123 " prefix); for branches, pass the branch name.
+    const label = item.kind === 'pr' ? item.label.replace(/^#\d+\s*/, '') : item.branchName;
+    onSelect?.({ kind: item.kind, branchName: item.branchName, label });
+  }
+
+  function handleKeydown(e: KeyboardEvent) {
+    if (!showDropdown || filteredItems.length === 0) return;
+
+    if (e.key === 'ArrowDown') {
+      e.preventDefault();
+      highlightedIndex = Math.min(highlightedIndex + 1, filteredItems.length - 1);
+    } else if (e.key === 'ArrowUp') {
+      e.preventDefault();
+      highlightedIndex = Math.max(highlightedIndex - 1, -1);
+    } else if (e.key === 'Enter' && highlightedIndex >= 0) {
+      e.preventDefault();
+      e.stopPropagation();
+      selectItem(filteredItems[highlightedIndex]);
+    } else if (e.key === 'Escape') {
+      showDropdown = false;
+      highlightedIndex = -1;
+    } else if (e.key === 'Tab' && highlightedIndex >= 0) {
+      e.preventDefault();
+      selectItem(filteredItems[highlightedIndex]);
+    }
+  }
+</script>
+
+<div class="branch-picker-wrapper">
+  <div class="input-container">
+    <input
+      bind:this={inputEl}
+      class="branch-input"
+      type="text"
+      bind:value
+      oninput={handleInput}
+      onfocus={handleFocus}
+      onblur={handleBlur}
+      onkeydown={handleKeydown}
+      id="project-branch"
+      placeholder="Search PRs or branches…"
+      autocomplete="off"
+      autocorrect="off"
+      autocapitalize="off"
+      spellcheck={false}
+      {disabled}
+    />
+  </div>
+
+  {#if showDropdown && filteredItems.length > 0 && !disabled}
+    <div class="suggestions-dropdown">
+      {#each filteredItems as item, i}
+        <button
+          class="suggestion-item"
+          class:highlighted={i === highlightedIndex}
+          onmousedown={(e) => {
+            e.preventDefault();
+            selectItem(item);
+          }}
+        >
+          {#if item.kind === 'pr'}
+            <GitPullRequest size={14} />
+          {:else}
+            <GitBranch size={14} />
+          {/if}
+          <span class="suggestion-label">{item.label}</span>
+          {#if item.detail}
+            <span class="suggestion-detail">{item.detail}</span>
+          {/if}
+        </button>
+      {/each}
+    </div>
+  {:else if showDropdown && loading && !disabled}
+    <div class="suggestions-dropdown">
+      <div class="loading-hint">Loading…</div>
+    </div>
+  {/if}
+
+  {#if matchedPr}
+    <div class="pr-info-card">
+      <GitPullRequest size={14} class="pr-info-icon" />
+      <div class="pr-info-content">
+        <span class="pr-info-title">#{matchedPr.number} {matchedPr.title}</span>
+        <span class="pr-info-meta"
+          >{matchedPr.author} · {matchedPr.baseRef}{#if matchedPr.draft}
+            · Draft{/if}</span
+        >
+      </div>
+    </div>
+  {/if}
+</div>
+
+<style>
+  .branch-picker-wrapper {
+    position: relative;
+  }
+
+  .input-container {
+    position: relative;
+    display: flex;
+    align-items: center;
+  }
+
+  .branch-input {
+    width: 100%;
+    min-height: 42px;
+    border: 1.5px solid var(--border-muted);
+    background: transparent;
+    color: var(--text-primary);
+    border-radius: 10px;
+    padding: 10px 14px;
+    font-size: var(--size-md);
+    font-family: inherit;
+    outline: none;
+    transition: border-color 0.15s ease;
+    box-sizing: border-box;
+  }
+
+  .branch-input:focus {
+    border-color: var(--ui-accent);
+  }
+
+  .branch-input::placeholder {
+    color: var(--text-faint);
+  }
+
+  .branch-input:disabled {
+    opacity: 0.6;
+  }
+
+  .suggestions-dropdown {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    right: 0;
+    margin-top: 4px;
+    background: var(--bg-chrome);
+    border: 1px solid var(--border-muted);
+    border-radius: 8px;
+    max-height: 200px;
+    overflow-y: auto;
+    z-index: 100;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+  }
+
+  .suggestion-item {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    width: 100%;
+    padding: 8px 12px;
+    border: none;
+    background: transparent;
+    color: var(--text-primary);
+    font-size: var(--size-sm);
+    font-family: inherit;
+    cursor: pointer;
+    text-align: left;
+    transition: background-color 0.1s ease;
+  }
+
+  .suggestion-item:hover,
+  .suggestion-item.highlighted {
+    background: var(--bg-hover);
+  }
+
+  .suggestion-item :global(svg) {
+    color: var(--text-faint);
+    flex-shrink: 0;
+  }
+
+  .suggestion-label {
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    min-width: 0;
+  }
+
+  .suggestion-detail {
+    margin-left: auto;
+    font-size: var(--size-xs);
+    color: var(--text-faint);
+    flex-shrink: 0;
+  }
+
+  .loading-hint {
+    padding: 8px 12px;
+    font-size: var(--size-sm);
+    color: var(--text-faint);
+  }
+
+  .pr-info-card {
+    display: flex;
+    align-items: flex-start;
+    gap: 8px;
+    margin-top: 6px;
+    padding: 8px 12px;
+    background: var(--bg-hover);
+    border-radius: 8px;
+  }
+
+  .pr-info-card :global(.pr-info-icon) {
+    color: var(--text-faint);
+    flex-shrink: 0;
+    margin-top: 1px;
+  }
+
+  .pr-info-content {
+    display: flex;
+    flex-direction: column;
+    gap: 2px;
+    min-width: 0;
+  }
+
+  .pr-info-title {
+    font-size: var(--size-sm);
+    color: var(--text-primary);
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+  }
+
+  .pr-info-meta {
+    font-size: var(--size-xs);
+    color: var(--text-faint);
+  }
+</style>
diff --git a/apps/staged/src/lib/features/projects/GitHubRepoPicker.svelte b/apps/staged/src/lib/features/projects/GitHubRepoPicker.svelte
index 49f8c370..238bfb11 100644
--- a/apps/staged/src/lib/features/projects/GitHubRepoPicker.svelte
+++ b/apps/staged/src/lib/features/projects/GitHubRepoPicker.svelte
@@ -10,9 +10,10 @@
   import Spinner from '../../shared/Spinner.svelte';
   import * as commands from '../../api/commands';
   import type { GitHubRepo, RecentRepo } from '../../types';
+  import { parseGitHubUrl, type RepoSelection } from '../../shared/githubUrl';
 
   interface Props {
-    onSelect: (nameWithOwner: string, subpath?: string) => void;
+    onSelect: (selection: RepoSelection) => void;
     onBack: () => void;
     excludeRepos?: Set<string>;
     showHeader?: boolean;
@@ -31,14 +32,6 @@
   let isSearching = $state(false);
   let directFetchRepo = $state<GitHubRepo | null>(null);
 
-  function parseGitHubUrl(input: string): string | null {
-    const trimmed = input.trim();
-    const match = trimmed.match(
-      /^(?:https?:\/\/)?github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\/.*|\.git)?$/
-    );
-    return match ? match[1] : null;
-  }
-
   function isOwnerRepoFormat(input: string): boolean {
     const trimmed = input.trim();
     return /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(trimmed);
@@ -122,6 +115,19 @@
 
     const parsed = parseGitHubUrl(trimmed);
     if (parsed) {
+      if (parsed.prNumber) {
+        // PR URL: resolve the PR's head branch before selecting
+        try {
+          const prs = await commands.listPullRequests(parsed.nameWithOwner);
+          const pr = prs.find((p) => p.number === parsed.prNumber);
+          if (pr) {
+            onSelect({ ...parsed, branchName: pr.headRef });
+            return;
+          }
+        } catch {
+          // Couldn't fetch PRs — fall through with just the repo
+        }
+      }
       onSelect(parsed);
       return;
     }
@@ -207,7 +213,7 @@
       bind:this={searchInputEl}
       bind:value={query}
       type="text"
-      placeholder="Search or paste a repository..."
+      placeholder="Search or paste a repo or PR link..."
       autocomplete="off"
       autocorrect="off"
       spellcheck="false"
@@ -221,7 +227,8 @@
         <button
           class="repo-item recent"
           tabindex="-1"
-          onclick={() => onSelect(recent.githubRepo, recent.subpath ?? undefined)}
+          onclick={() =>
+            onSelect({ nameWithOwner: recent.githubRepo, subpath: recent.subpath ?? undefined })}
         >
           <div class="repo-icon recent-icon">
             <Clock size={14} />
@@ -266,7 +273,11 @@
       {#each displayItems as item}
         {#if item.type === 'repo'}
           {@const repo = item.data as GitHubRepo}
-          <button class="repo-item" tabindex="-1" onclick={() => onSelect(repo.nameWithOwner)}>
+          <button
+            class="repo-item"
+            tabindex="-1"
+            onclick={() => onSelect({ nameWithOwner: repo.nameWithOwner })}
+          >
             <div class="repo-icon">
               {#if repo.isPrivate}
                 <Lock size={14} />
diff --git a/apps/staged/src/lib/features/projects/NewProjectForm.svelte b/apps/staged/src/lib/features/projects/NewProjectForm.svelte
index ca3a3d02..f34d1fa0 100644
--- a/apps/staged/src/lib/features/projects/NewProjectForm.svelte
+++ b/apps/staged/src/lib/features/projects/NewProjectForm.svelte
@@ -17,6 +17,10 @@
   import RepoSearchInput from './RepoSearchInput.svelte';
   import SubpathInput from './SubpathInput.svelte';
   import type { SubpathInputApi } from './SubpathInput.svelte';
+  import BranchPicker, { type BranchSelection } from './BranchPicker.svelte';
+  import type { RepoSelection } from '../../shared/githubUrl';
+  import { parseGitHubUrl } from '../../shared/githubUrl';
+  import type { PullRequest } from '../../types';
 
   interface Props {
     onCreated: (project: Project) => void;
@@ -36,6 +40,10 @@
     subpath = $bindable(''),
   }: Props = $props();
 
+  let branchName = $state('');
+  let isNewBranch = $state(false);
+  let matchedPr = $state<PullRequest | null>(null);
+
   let saving = $state(false);
   let error = $state<string | null>(null);
   let isMonorepo = $state(false);
@@ -103,11 +111,16 @@
         ? subpath.trim().replace(/^\/+|\/+$/g, '') || undefined
         : undefined;
 
+      const normalizedBranch = selectedRepo ? branchName.trim() || undefined : undefined;
+      const prNumber = matchedPr?.number ?? undefined;
+
       const project = await commands.createProject(
         name.trim(),
         location,
         selectedRepo ?? undefined,
-        normalizedSubpath
+        normalizedSubpath,
+        normalizedBranch,
+        prNumber
       );
       onCreated(project);
     } catch (e) {
@@ -129,7 +142,10 @@
       if (idx < recentRepos.length) {
         e.preventDefault();
         const recent = recentRepos[idx];
-        handleRepoSelected(recent.githubRepo, recent.subpath ?? undefined);
+        handleRepoSelected({
+          nameWithOwner: recent.githubRepo,
+          subpath: recent.subpath ?? undefined,
+        });
       }
       return;
     }
@@ -139,14 +155,45 @@
       if (target.closest('.repo-search-wrapper')) return;
       // Don't submit if a suggestion is highlighted in the subpath dropdown
       if (target.closest('.subpath-input-wrapper')) return;
+      // Don't submit if a suggestion is highlighted in the branch picker dropdown
+      if (target.closest('.branch-picker-wrapper')) return;
       e.preventDefault();
       handleCreate();
     }
   }
 
-  function handleRepoSelected(nameWithOwner: string, selectedSubpath?: string) {
-    selectedRepo = nameWithOwner;
-    subpath = selectedSubpath ?? '';
+  /** Derive a human-friendly project name from a branch name like "feat/dark-mode". */
+  function nameFromBranch(branch: string): string {
+    const last = branch.split('/').pop() ?? branch;
+    if (!last) return branch;
+    const spaced = last.replace(/[-_]/g, ' ');
+    return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+  }
+
+  function handleBranchSelected(selection: BranchSelection) {
+    if (!name.trim()) {
+      name = selection.kind === 'pr' ? selection.label : nameFromBranch(selection.branchName);
+    }
+  }
+
+  function handleNameInput() {
+    const parsed = parseGitHubUrl(name);
+    if (parsed) {
+      name = '';
+      handleRepoSelected(parsed);
+      // Blur the name field so focus doesn't jump into the newly-revealed BranchPicker
+      (document.activeElement as HTMLElement | null)?.blur();
+    }
+  }
+
+  let pendingPrNumber = $state<number | null>(null);
+  let pendingBranchName = $state<string | null>(null);
+
+  function handleRepoSelected(selection: RepoSelection) {
+    selectedRepo = selection.nameWithOwner;
+    subpath = selection.subpath ?? '';
+    pendingPrNumber = selection.prNumber ?? null;
+    pendingBranchName = selection.branchName ?? null;
   }
 </script>
 
@@ -165,6 +212,7 @@
       autocapitalize="off"
       spellcheck={false}
       autofocus
+      oninput={handleNameInput}
     />
   </div>
 
@@ -203,6 +251,10 @@
           onclick={() => {
             selectedRepo = null;
             subpath = '';
+            branchName = '';
+            matchedPr = null;
+            pendingPrNumber = null;
+            pendingBranchName = null;
           }}
         >
           <X size={14} />
@@ -217,7 +269,11 @@
         {#each recentRepos.slice(0, 5) as recent, i}
           <button
             class="recent-repo-item"
-            onclick={() => handleRepoSelected(recent.githubRepo, recent.subpath ?? undefined)}
+            onclick={() =>
+              handleRepoSelected({
+                nameWithOwner: recent.githubRepo,
+                subpath: recent.subpath ?? undefined,
+              })}
           >
             <Clock size={12} class="recent-repo-icon" />
             <span class="recent-repo-label">
@@ -248,6 +304,25 @@
         bind:api={subpathApi}
       />
     </div>
+
+    <div class="form-group">
+      <label for="project-branch"
+        >PR or Branch
+        <span class="field-badge {isNewBranch ? 'new-branch' : 'optional'}"
+          >{isNewBranch ? 'New branch' : 'Optional'}</span
+        ></label
+      >
+      <BranchPicker
+        bind:value={branchName}
+        bind:isNewBranch
+        bind:matchedPr
+        bind:initialPrNumber={pendingPrNumber}
+        bind:initialBranchName={pendingBranchName}
+        repo={selectedRepo}
+        disabled={saving}
+        onSelect={handleBranchSelected}
+      />
+    </div>
   {/if}
 
   {#if error}
@@ -320,6 +395,11 @@
     color: var(--bg-deepest);
   }
 
+  .field-badge.new-branch {
+    background-color: var(--ui-accent);
+    color: var(--bg-deepest);
+  }
+
   .repo-info {
     display: flex;
     align-items: center;
diff --git a/apps/staged/src/lib/features/projects/ProjectHome.svelte b/apps/staged/src/lib/features/projects/ProjectHome.svelte
index c0a4ba4d..b160569b 100644
--- a/apps/staged/src/lib/features/projects/ProjectHome.svelte
+++ b/apps/staged/src/lib/features/projects/ProjectHome.svelte
@@ -14,6 +14,7 @@
   import { projectDisplayName } from '../../shared/utils';
   import { goHome, selectProject } from '../layout/navigation.svelte';
   import ProjectSection from './ProjectSection.svelte';
+  import type { RepoSelection as RepoPickerSelection } from '../../shared/githubUrl';
   import NewProjectModal from './NewProjectModal.svelte';
   import ProjectsSidebar from './ProjectsSidebar.svelte';
   import ConfirmDialog from '../../shared/ConfirmDialog.svelte';
@@ -486,9 +487,16 @@
 
   // ── Branch actions ──
 
-  async function handleRepoSelected(projectId: string, nameWithOwner: string, subpath?: string) {
+  async function handleRepoSelected(projectId: string, selection: RepoPickerSelection) {
     try {
-      await commands.addProjectRepo(projectId, nameWithOwner, undefined, subpath);
+      await commands.addProjectRepo(
+        projectId,
+        selection.nameWithOwner,
+        selection.branchName,
+        selection.subpath,
+        undefined,
+        selection.prNumber
+      );
       const [projectsList, branches, repos] = await Promise.all([
         commands.listProjects(),
         commands.listBranchesForProject(projectId),
@@ -733,8 +741,7 @@
             excludeRepos={new Set(
               [...(repoLabelsByProject.get(project.id)?.values() ?? [])].map((r) => r.githubRepo)
             )}
-            onRepoSelected={(nameWithOwner, subpath) =>
-              handleRepoSelected(project.id, nameWithOwner, subpath)}
+            onRepoSelected={(selection) => handleRepoSelected(project.id, selection)}
             onRetryWorktree={(branchId) => setupBranchWorktree(branchId, project.id)}
           />
         {/each}
diff --git a/apps/staged/src/lib/features/projects/ProjectSection.svelte b/apps/staged/src/lib/features/projects/ProjectSection.svelte
index ac157bb2..7a8520ba 100644
--- a/apps/staged/src/lib/features/projects/ProjectSection.svelte
+++ b/apps/staged/src/lib/features/projects/ProjectSection.svelte
@@ -31,6 +31,7 @@
   import BranchCard from '../branches/BranchCard.svelte';
   import Spinner from '../../shared/Spinner.svelte';
   import GitHubRepoPicker from './GitHubRepoPicker.svelte';
+  import type { RepoSelection as RepoPickerSelection } from '../../shared/githubUrl';
   import TimelineRow from '../timeline/TimelineRow.svelte';
   import NoteModal from '../notes/NoteModal.svelte';
   import SessionModal from '../sessions/SessionModal.svelte';
@@ -65,7 +66,7 @@
       status: WorkspaceStatus,
       workstationId?: number | null
     ) => void;
-    onRepoSelected?: (nameWithOwner: string, subpath?: string) => void;
+    onRepoSelected?: (selection: RepoPickerSelection) => void;
     onRetryWorktree?: (branchId: string) => void;
   }
 
@@ -140,9 +141,9 @@
     }
   }
 
-  function handleRepoSelected(nameWithOwner: string, subpath?: string) {
+  function handleRepoSelected(selection: RepoPickerSelection) {
     dropdownOpen = false;
-    onRepoSelected?.(nameWithOwner, subpath);
+    onRepoSelected?.(selection);
   }
 
   $effect(() => {
diff --git a/apps/staged/src/lib/features/projects/RepoSearchInput.svelte b/apps/staged/src/lib/features/projects/RepoSearchInput.svelte
index 35466c2b..1fd6cce2 100644
--- a/apps/staged/src/lib/features/projects/RepoSearchInput.svelte
+++ b/apps/staged/src/lib/features/projects/RepoSearchInput.svelte
@@ -12,9 +12,12 @@
   import RepoLabel from '../../shared/RepoLabel.svelte';
   import * as commands from '../../api/commands';
   import type { GitHubRepo, RecentRepo } from '../../types';
+  import { parseGitHubUrl, type RepoSelection } from '../../shared/githubUrl';
+
+  export type { RepoSelection };
 
   interface Props {
-    onSelect: (nameWithOwner: string, subpath?: string) => void;
+    onSelect: (selection: RepoSelection) => void;
     disabled?: boolean;
   }
 
@@ -42,14 +45,6 @@
     dropdownStyle = `position:fixed;top:${top}px;left:${rect.left}px;width:${rect.width}px;max-height:${maxH}px`;
   }
 
-  function parseGitHubUrl(input: string): string | null {
-    const trimmed = input.trim();
-    const match = trimmed.match(
-      /^(?:https?:\/\/)?github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\/.*|\.git)?$/
-    );
-    return match ? match[1] : null;
-  }
-
   function isOwnerRepoFormat(input: string): boolean {
     const trimmed = input.trim();
     return /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(trimmed);
@@ -122,10 +117,10 @@
     if (searchTimer) clearTimeout(searchTimer);
   });
 
-  function handleSelect(nameWithOwner: string, subpath?: string) {
+  function handleSelect(selection: RepoSelection) {
     query = '';
     dropdownOpen = false;
-    onSelect(nameWithOwner, subpath);
+    onSelect(selection);
   }
 
   async function handleInput() {
@@ -134,6 +129,8 @@
     const parsed = parseGitHubUrl(trimmed);
     if (parsed) {
       handleSelect(parsed);
+      // Blur so focus doesn't jump into the newly-revealed BranchPicker
+      inputEl?.blur();
       return;
     }
 
@@ -272,7 +269,11 @@
           <button
             class="repo-item recent"
             tabindex="-1"
-            onclick={() => handleSelect(recent.githubRepo, recent.subpath ?? undefined)}
+            onclick={() =>
+              handleSelect({
+                nameWithOwner: recent.githubRepo,
+                subpath: recent.subpath ?? undefined,
+              })}
           >
             <div class="repo-icon recent-icon">
               <Clock size={14} />
@@ -325,7 +326,7 @@
             <button
               class="repo-item"
               tabindex="-1"
-              onclick={() => handleSelect(repo.nameWithOwner)}
+              onclick={() => handleSelect({ nameWithOwner: repo.nameWithOwner })}
             >
               <div class="repo-icon">
                 {#if repo.isPrivate}
diff --git a/apps/staged/src/lib/shared/githubUrl.ts b/apps/staged/src/lib/shared/githubUrl.ts
new file mode 100644
index 00000000..ea170500
--- /dev/null
+++ b/apps/staged/src/lib/shared/githubUrl.ts
@@ -0,0 +1,47 @@
+export interface RepoSelection {
+  nameWithOwner: string;
+  subpath?: string;
+  prNumber?: number;
+  branchName?: string;
+}
+
+/**
+ * Parse a GitHub URL into a RepoSelection.
+ *
+ * Supports:
+ * - PR URLs:     github.com/owner/repo/pull/123
+ * - Branch URLs: github.com/owner/repo/tree/branch-name
+ * - Repo URLs:   github.com/owner/repo
+ */
+export function parseGitHubUrl(input: string): RepoSelection | null {
+  const trimmed = input.trim();
+
+  // Match PR URLs: github.com/owner/repo/pull/123
+  const prMatch = trimmed.match(
+    /^(?:https?:\/\/)?github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)\/pull\/(\d+)(?:\/.*)?$/
+  );
+  if (prMatch) {
+    return { nameWithOwner: prMatch[1], prNumber: parseInt(prMatch[2], 10) };
+  }
+
+  // Match branch/tree URLs: github.com/owner/repo/tree/branch-name
+  // Branch names can contain slashes, so capture everything after /tree/
+  const treeMatch = trimmed.match(
+    /^(?:https?:\/\/)?github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)\/tree\/(.+?)(?:[?#].*)?$/
+  );
+  if (treeMatch) {
+    return { nameWithOwner: treeMatch[1], branchName: treeMatch[2] };
+  }
+
+  // Plain repo URL: github.com/owner/repo
+  // NOTE: This pattern also matches PR and tree URLs (capturing just owner/repo),
+  // so it must remain last — the ordering of these three checks is load-bearing.
+  const repoMatch = trimmed.match(
+    /^(?:https?:\/\/)?github\.com\/([A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+?)(?:\/.*|\.git)?$/
+  );
+  if (repoMatch) {
+    return { nameWithOwner: repoMatch[1] };
+  }
+
+  return null;
+}