diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 091ecce1fa..8d2dc79a3f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -241,8 +241,8 @@ jobs:
         with:
           path: ${{ env.PLAYWRIGHT_BROWSERS_PATH }}
           key: playwright-${{ runner.os }}-${{ steps.pw-version.outputs.version }}
-      - name: Desktop build
-        run: just desktop-build
+      - name: Desktop E2E build
+        run: pnpm -C desktop build:e2e
       - name: Desktop smoke e2e
         run: cd desktop && pnpm exec playwright test --project=smoke --shard=${{ matrix.shard }}/4
       - name: Summarize flaky tests
@@ -393,8 +393,8 @@ jobs:
         with:
           path: ${{ env.PLAYWRIGHT_BROWSERS_PATH }}
           key: playwright-${{ runner.os }}-${{ steps.pw-version.outputs.version }}
-      - name: Desktop build
-        run: just desktop-build
+      - name: Desktop E2E build
+        run: pnpm -C desktop build:e2e
       - name: Wait for integration services
         run: |
           wait_healthy() {
diff --git a/Justfile b/Justfile
index b8bf80559d..2f5ea0e89f 100644
--- a/Justfile
+++ b/Justfile
@@ -248,7 +248,7 @@ desktop-e2e-integration: _ensure-migrations
 # Run only the e2e specs changed vs origin/main (both projects) before pushing
 desktop-e2e-pre-push: _ensure-migrations
     git fetch origin main
-    cd {{desktop_dir}} && pnpm build && pnpm exec playwright test --only-changed=origin/main
+    cd {{desktop_dir}} && pnpm build:e2e && pnpm exec playwright test --only-changed=origin/main
 
 # Run all checks suitable for CI / pre-push (no infra needed)
 ci: check test-unit desktop-test desktop-build desktop-tauri-check desktop-tauri-test web-build mobile-test
@@ -340,7 +340,7 @@ mesh-e2e-confidence:
 desktop-screenshot *ARGS:
     #!/usr/bin/env bash
     set -euo pipefail
-    just desktop-build
+    pnpm -C {{desktop_dir}} build:e2e
     cd {{desktop_dir}}
     if ! curl -sf http://127.0.0.1:4173/ >/dev/null 2>&1; then
         python3 -m http.server 4173 -d dist >/dev/null 2>&1 &
diff --git a/desktop/package.json b/desktop/package.json
index e0b8017d27..60d01d0a67 100644
--- a/desktop/package.json
+++ b/desktop/package.json
@@ -6,6 +6,7 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
+    "build:e2e": "tsc && vite build --mode e2e",
     "typecheck": "tsc --noEmit",
     "check:file-sizes": "node ./scripts/check-file-sizes.mjs",
     "check:px-text": "node ./scripts/check-px-text.mjs",
@@ -16,9 +17,9 @@
     "test": "node --import ./test-loader.mjs --experimental-strip-types --test 'src/**/*.test.mjs'",
     "preview": "vite preview",
     "tauri": "tauri",
-    "test:e2e": "pnpm build && playwright test",
-    "test:e2e:smoke": "pnpm build && playwright test --project=smoke",
-    "test:e2e:integration": "pnpm build && playwright test --project=integration",
+    "test:e2e": "pnpm build:e2e && playwright test",
+    "test:e2e:smoke": "pnpm build:e2e && playwright test --project=smoke",
+    "test:e2e:integration": "pnpm build:e2e && playwright test --project=integration",
     "test:e2e:report": "playwright show-report",
     "tauri:build": "tauri build"
   },
diff --git a/desktop/src-tauri/src/commands/mod.rs b/desktop/src-tauri/src/commands/mod.rs
index eaa608c339..3de7c68454 100644
--- a/desktop/src-tauri/src/commands/mod.rs
+++ b/desktop/src-tauri/src/commands/mod.rs
@@ -37,6 +37,7 @@ mod profile;
 mod project_git;
 mod project_git_diff;
 mod project_git_exec;
+mod project_git_workflow;
 mod project_repo_paths;
 mod project_terminal;
 mod relay_members;
@@ -45,6 +46,7 @@ mod social;
 mod team_snapshot;
 mod teams;
 mod updater;
+mod window_chrome;
 mod window_vibrancy;
 mod workflows;
 mod workspace;
@@ -84,6 +86,7 @@ pub use prevent_sleep::*;
 pub use profile::*;
 pub use project_git::*;
 pub use project_git_diff::*;
+pub use project_git_workflow::*;
 pub use project_terminal::*;
 pub use relay_members::*;
 pub use relay_reconnect::*;
@@ -91,6 +94,7 @@ pub use social::*;
 pub use team_snapshot::*;
 pub use teams::*;
 pub use updater::*;
+pub use window_chrome::*;
 pub use window_vibrancy::*;
 pub use workflows::*;
 pub use workspace::*;
diff --git a/desktop/src-tauri/src/commands/project_git.rs b/desktop/src-tauri/src/commands/project_git.rs
index 743e29f740..3af0abd2da 100644
--- a/desktop/src-tauri/src/commands/project_git.rs
+++ b/desktop/src-tauri/src/commands/project_git.rs
@@ -1,5 +1,5 @@
 use super::project_git_exec::{
-    build_git_auth_config, clean_branch, run_git, validate_clone_url, GitAuthConfig,
+    build_git_auth_config, clean_branch, run_git, validate_workspace_clone_url, GitAuthConfig,
 };
 use super::project_repo_paths::{canonical_repos_roots, find_local_repo_dir};
 use crate::app_state::AppState;
@@ -57,6 +57,7 @@ pub struct ProjectRepoSyncStatusInfo {
     pub remote_branch: Option<String>,
     pub remote_head: Option<String>,
     pub remote_short_head: Option<String>,
+    pub merge_base: Option<String>,
     pub ahead_count: usize,
     pub behind_count: usize,
     pub has_uncommitted_changes: bool,
@@ -70,6 +71,9 @@ pub struct ProjectRepoSyncStatusInfo {
 pub struct ProjectRepoPushResult {
     pub pushed: bool,
     pub message: String,
+    pub branch: String,
+    pub commit: String,
+    pub merge_base: Option<String>,
 }
 #[derive(Serialize)]
 pub struct ProjectRepoPullResult {
@@ -104,7 +108,7 @@ fn short_hash(hash: &str) -> String {
     hash.chars().take(7).collect()
 }
 
-fn first_output_line(output: &str) -> Option<String> {
+pub(crate) fn first_output_line(output: &str) -> Option<String> {
     output
         .lines()
         .next()
@@ -492,6 +496,7 @@ fn compare_local_remote_status(
     repo_dir: &std::path::Path,
     clone_url: &str,
     branch_name: Option<&str>,
+    base_branch: Option<&str>,
     auth: &GitAuthConfig,
 ) -> ProjectRepoSyncStatusInfo {
     let local_branch = run_git(&["branch", "--show-current"], Some(repo_dir), auth)
@@ -518,18 +523,20 @@ fn compare_local_remote_status(
             auth,
         );
     }
-    let _ = run_git(
-        &[
-            "fetch",
-            "--quiet",
-            "--depth=100",
-            "--end-of-options",
-            "origin",
-            branch.as_str(),
-        ],
-        Some(repo_dir),
-        auth,
-    );
+    let base_branch =
+        normalize_branch_option(base_branch).filter(|base_branch| *base_branch != branch);
+    let mut fetch_args = vec![
+        "fetch",
+        "--quiet",
+        "--depth=100",
+        "--end-of-options",
+        "origin",
+        branch.as_str(),
+    ];
+    if let Some(base_branch) = base_branch.as_deref() {
+        fetch_args.push(base_branch);
+    }
+    let _ = run_git(&fetch_args, Some(repo_dir), auth);
 
     let local_head = run_git(&["rev-parse", "HEAD"], Some(repo_dir), auth)
         .ok()
@@ -542,6 +549,19 @@ fn compare_local_remote_status(
     )
     .ok()
     .and_then(|output| first_output_line(&output));
+    let merge_base = base_branch.as_deref().and_then(|base_branch| {
+        run_git(
+            &[
+                "merge-base",
+                "HEAD",
+                format!("origin/{base_branch}").as_str(),
+            ],
+            Some(repo_dir),
+            auth,
+        )
+        .ok()
+        .and_then(|output| first_output_line(&output))
+    });
     let status = run_git(&["status", "--porcelain"], Some(repo_dir), auth).unwrap_or_default();
     let has_uncommitted_changes = has_uncommitted_changes(&status);
     let has_untracked_files = has_untracked_files(&status);
@@ -576,6 +596,10 @@ fn compare_local_remote_status(
 
     let push_block_reason = if local_head.is_none() {
         Some("No local commits to push.".to_string())
+    } else if local_branch.as_deref() != Some(branch.as_str()) {
+        Some(format!(
+            "Local checkout is on a different branch than {branch}."
+        ))
     } else if has_uncommitted_changes || has_untracked_files {
         Some("Commit or discard local changes before pushing.".to_string())
     } else if behind_count > 0 {
@@ -615,6 +639,7 @@ fn compare_local_remote_status(
         remote_branch: Some(branch),
         remote_head: remote_head.clone(),
         remote_short_head: remote_head.as_deref().map(short_hash),
+        merge_base,
         ahead_count,
         behind_count,
         has_uncommitted_changes,
@@ -657,7 +682,7 @@ pub async fn get_project_repo_snapshot(
     target_commit: Option<String>,
     state: State<'_, AppState>,
 ) -> Result<ProjectRepoSnapshotInfo, String> {
-    validate_clone_url(&clone_url)?;
+    validate_workspace_clone_url(&clone_url, &state)?;
     let auth = build_git_auth_config(&state)?;
     let branch = clean_branch(default_branch);
     let base_branch = clean_branch(base_branch);
@@ -793,10 +818,11 @@ pub async fn get_project_repo_sync_status(
     repos_dir: Option<String>,
     project_dtag: String,
     clone_url: String,
-    default_branch: Option<String>,
+    branch_name: Option<String>,
+    base_branch: Option<String>,
     state: State<'_, AppState>,
 ) -> Result<ProjectRepoSyncStatusInfo, String> {
-    validate_clone_url(&clone_url)?;
+    validate_workspace_clone_url(&clone_url, &state)?;
     let auth = build_git_auth_config(&state)?;
 
     tauri::async_runtime::spawn_blocking(move || {
@@ -808,11 +834,12 @@ pub async fn get_project_repo_sync_status(
                 local_branch: None,
                 local_head: None,
                 local_short_head: None,
-                remote_branch: default_branch
+                remote_branch: branch_name
                     .as_deref()
                     .and_then(|branch| normalize_branch_option(Some(branch))),
                 remote_head: None,
                 remote_short_head: None,
+                merge_base: None,
                 ahead_count: 0,
                 behind_count: 0,
                 has_uncommitted_changes: false,
@@ -827,7 +854,8 @@ pub async fn get_project_repo_sync_status(
         Ok(compare_local_remote_status(
             &repo_dir,
             &clone_url,
-            default_branch.as_deref(),
+            branch_name.as_deref(),
+            base_branch.as_deref(),
             &auth,
         ))
     })
@@ -840,10 +868,11 @@ pub async fn push_project_local_repository(
     repos_dir: Option<String>,
     project_dtag: String,
     clone_url: String,
-    default_branch: Option<String>,
+    branch_name: Option<String>,
+    base_branch: Option<String>,
     state: State<'_, AppState>,
 ) -> Result<ProjectRepoPushResult, String> {
-    validate_clone_url(&clone_url)?;
+    validate_workspace_clone_url(&clone_url, &state)?;
     let auth = build_git_auth_config(&state)?;
 
     tauri::async_runtime::spawn_blocking(move || {
@@ -852,8 +881,13 @@ pub async fn push_project_local_repository(
         else {
             return Err("No local checkout found.".to_string());
         };
-        let status =
-            compare_local_remote_status(&repo_dir, &clone_url, default_branch.as_deref(), &auth);
+        let status = compare_local_remote_status(
+            &repo_dir,
+            &clone_url,
+            branch_name.as_deref(),
+            base_branch.as_deref(),
+            &auth,
+        );
         if !status.can_push {
             return Err(status
                 .push_block_reason
@@ -861,8 +895,12 @@ pub async fn push_project_local_repository(
         }
         let branch = status
             .remote_branch
-            .as_deref()
+            .clone()
             .ok_or_else(|| "No branch selected for push.".to_string())?;
+        let commit = status
+            .local_head
+            .clone()
+            .ok_or_else(|| "No local commit selected for push.".to_string())?;
         run_git(
             &[
                 "push",
@@ -877,6 +915,9 @@ pub async fn push_project_local_repository(
         Ok(ProjectRepoPushResult {
             pushed: true,
             message: format!("Pushed {branch} to remote."),
+            branch,
+            commit,
+            merge_base: status.merge_base,
         })
     })
     .await
@@ -890,10 +931,10 @@ pub async fn pull_project_local_repository(
     repos_dir: Option<String>,
     project_dtag: String,
     clone_url: String,
-    default_branch: Option<String>,
+    branch_name: Option<String>,
     state: State<'_, AppState>,
 ) -> Result<ProjectRepoPullResult, String> {
-    validate_clone_url(&clone_url)?;
+    validate_workspace_clone_url(&clone_url, &state)?;
     let auth = build_git_auth_config(&state)?;
 
     tauri::async_runtime::spawn_blocking(move || {
@@ -903,7 +944,7 @@ pub async fn pull_project_local_repository(
             return Err("No local checkout found.".to_string());
         };
         let status =
-            compare_local_remote_status(&repo_dir, &clone_url, default_branch.as_deref(), &auth);
+            compare_local_remote_status(&repo_dir, &clone_url, branch_name.as_deref(), None, &auth);
         if !status.can_pull {
             return Err(status
                 .pull_block_reason
diff --git a/desktop/src-tauri/src/commands/project_git_diff.rs b/desktop/src-tauri/src/commands/project_git_diff.rs
index 9111272211..0bd07cbffd 100644
--- a/desktop/src-tauri/src/commands/project_git_diff.rs
+++ b/desktop/src-tauri/src/commands/project_git_diff.rs
@@ -1,5 +1,5 @@
 use super::project_git_exec::{
-    build_git_auth_config, clean_branch, run_git, validate_clone_url, GitAuthConfig,
+    build_git_auth_config, clean_branch, run_git, validate_workspace_clone_url, GitAuthConfig,
 };
 use super::project_repo_paths::find_local_repo_dir;
 use crate::app_state::AppState;
@@ -37,7 +37,7 @@ fn clean_target_ref(value: Option<String>) -> Option<String> {
     })
 }
 
-fn clean_commit(value: Option<String>) -> Option<String> {
+pub(crate) fn clean_commit(value: Option<String>) -> Option<String> {
     value
         .filter(|value| matches!(value.len(), 40 | 64))
         .filter(|value| value.chars().all(|c| c.is_ascii_hexdigit()))
@@ -388,7 +388,7 @@ pub async fn get_project_repo_diff(
     target_commit: Option<String>,
     state: State<'_, AppState>,
 ) -> Result<ProjectRepoDiffInfo, String> {
-    validate_clone_url(&clone_url)?;
+    validate_workspace_clone_url(&clone_url, &state)?;
     let auth = build_git_auth_config(&state)?;
     let branch = clean_branch(default_branch);
     let base_branch = clean_branch(base_branch);
diff --git a/desktop/src-tauri/src/commands/project_git_exec.rs b/desktop/src-tauri/src/commands/project_git_exec.rs
index 651ecf7ad7..6f3aa226bc 100644
--- a/desktop/src-tauri/src/commands/project_git_exec.rs
+++ b/desktop/src-tauri/src/commands/project_git_exec.rs
@@ -5,7 +5,7 @@
 //! variables so nothing key-related ever touches disk or global git config.
 
 use crate::{app_state::AppState, managed_agents::resolve_command};
-use nostr::ToBech32;
+use nostr::{Keys, ToBech32};
 use std::io::Read;
 use std::process::{Command, Stdio};
 use std::time::{Duration, Instant};
@@ -14,7 +14,35 @@ use url::Url;
 /// Wall-clock cap for a single git invocation. Remote operations talk to
 /// relay-supplied clone URLs, so a slow or adversarial remote must not pin
 /// `spawn_blocking` threads indefinitely.
-const GIT_TIMEOUT: Duration = Duration::from_secs(60);
+const LOCAL_GIT_TIMEOUT: Duration = Duration::from_secs(60);
+const REMOTE_GIT_TIMEOUT: Duration = Duration::from_secs(300);
+
+fn git_subcommand<'a>(args: &'a [&str]) -> Option<&'a str> {
+    let mut index = 0;
+    while let Some(argument) = args.get(index).copied() {
+        match argument {
+            "-c" | "--config" | "-C" | "--git-dir" | "--work-tree" => index += 2,
+            "--no-pager" | "--paginate" | "--end-of-options" => index += 1,
+            argument
+                if argument.starts_with("--config=")
+                    || argument.starts_with("--git-dir=")
+                    || argument.starts_with("--work-tree=") =>
+            {
+                index += 1;
+            }
+            argument if argument.starts_with('-') => index += 1,
+            subcommand => return Some(subcommand),
+        }
+    }
+    None
+}
+
+fn git_needs_credentials(args: &[&str]) -> bool {
+    matches!(
+        git_subcommand(args),
+        Some("clone" | "fetch" | "push" | "pull" | "ls-remote" | "merge")
+    )
+}
 
 pub(crate) struct GitAuthConfig {
     git_path: std::path::PathBuf,
@@ -41,7 +69,13 @@ pub(crate) fn run_git(
     if let Some(cwd) = cwd {
         command.current_dir(cwd);
     }
-    configure_git_auth(&mut command, auth);
+    let needs_credentials = git_needs_credentials(args);
+    let timeout = if needs_credentials {
+        REMOTE_GIT_TIMEOUT
+    } else {
+        LOCAL_GIT_TIMEOUT
+    };
+    configure_git_auth(&mut command, auth, needs_credentials);
     command.stdin(Stdio::null());
     command.stdout(Stdio::piped());
     command.stderr(Stdio::piped());
@@ -62,12 +96,12 @@ pub(crate) fn run_git(
         match child.try_wait() {
             Ok(Some(status)) => break status,
             Ok(None) => {
-                if started.elapsed() > GIT_TIMEOUT {
+                if started.elapsed() > timeout {
                     let _ = child.kill();
                     let _ = child.wait();
                     let _ = stdout_thread.join();
                     let _ = stderr_thread.join();
-                    return Err(format!("git timed out after {}s", GIT_TIMEOUT.as_secs()));
+                    return Err(format!("git timed out after {}s", timeout.as_secs()));
                 }
                 std::thread::sleep(Duration::from_millis(50));
             }
@@ -92,9 +126,20 @@ pub(crate) fn run_git(
     Ok(stdout)
 }
 
-fn configure_git_auth(command: &mut Command, auth: &GitAuthConfig) {
+fn configure_git_auth(command: &mut Command, auth: &GitAuthConfig, needs_credentials: bool) {
     command.env("GIT_TERMINAL_PROMPT", "0");
     command.env("GIT_CONFIG_NOSYSTEM", "1");
+    for key in [
+        "GIT_DIR",
+        "GIT_WORK_TREE",
+        "GIT_INDEX_FILE",
+        "GIT_OBJECT_DIRECTORY",
+        "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+        "GIT_SSH_COMMAND",
+        "GIT_EXTERNAL_DIFF",
+    ] {
+        command.env_remove(key);
+    }
     // Git for Windows maps `/dev/null` to `NUL` internally, so this value
     // disables the global config file on every platform.
     command.env("GIT_CONFIG_GLOBAL", "/dev/null");
@@ -106,12 +151,25 @@ fn configure_git_auth(command: &mut Command, auth: &GitAuthConfig) {
     let mut entries: Vec<(&str, String)> = vec![
         ("credential.helper", String::new()),
         ("core.hooksPath", "/dev/null".to_string()),
+        ("core.fsmonitor", "false".to_string()),
+        ("protocol.allow", "never".to_string()),
+        ("protocol.http.allow", "always".to_string()),
+        ("protocol.https.allow", "always".to_string()),
+        ("protocol.ext.allow", "never".to_string()),
+        ("protocol.file.allow", "never".to_string()),
     ];
-    if let Some(cred_helper) = &auth.credential_helper {
+    if needs_credentials {
+        let Some(cred_helper) = &auth.credential_helper else {
+            return apply_git_config(command, &entries);
+        };
         command.env("NOSTR_PRIVATE_KEY", &auth.nsec);
         entries.push(("credential.helper", cred_helper.display().to_string()));
         entries.push(("credential.useHttpPath", "true".to_string()));
     }
+    apply_git_config(command, &entries);
+}
+
+fn apply_git_config(command: &mut Command, entries: &[(&str, String)]) {
     command.env("GIT_CONFIG_COUNT", entries.len().to_string());
     for (index, (key, value)) in entries.iter().enumerate() {
         command.env(format!("GIT_CONFIG_KEY_{index}"), key);
@@ -120,14 +178,17 @@ fn configure_git_auth(command: &mut Command, auth: &GitAuthConfig) {
 }
 
 pub(crate) fn build_git_auth_config(state: &AppState) -> Result<GitAuthConfig, String> {
+    let keys = state.signing_keys()?;
+    build_git_auth_config_for_keys(&keys)
+}
+
+pub(crate) fn build_git_auth_config_for_keys(keys: &Keys) -> Result<GitAuthConfig, String> {
     let git_path = resolve_command("git").ok_or_else(|| "git was not found on PATH".to_string())?;
     let credential_helper = resolve_command("git-credential-nostr");
-    let nsec = {
-        let keys = state.keys.lock().map_err(|error| error.to_string())?;
-        keys.secret_key()
-            .to_bech32()
-            .map_err(|error| format!("encode identity key: {error}"))?
-    };
+    let nsec = keys
+        .secret_key()
+        .to_bech32()
+        .map_err(|error| format!("encode identity key: {error}"))?;
     Ok(GitAuthConfig {
         git_path,
         credential_helper,
@@ -171,21 +232,95 @@ pub(crate) fn validate_clone_url(clone_url: &str) -> Result<(), String> {
         .path_segments()
         .map(|segments| segments.filter(|s| !s.is_empty()).collect::<Vec<_>>())
         .unwrap_or_default();
-    let is_buzz_repo_path = segments.windows(3).any(|window| {
-        window[0] == "git"
-            && window[1].len() == 64
-            && window[1].chars().all(|c| c.is_ascii_hexdigit())
-            && !window[2].is_empty()
-    });
+    let is_buzz_repo_path = segments
+        .iter()
+        .rposition(|segment| *segment == "git")
+        .filter(|index| segments.len() == index + 3)
+        .map(|index| {
+            segments[index + 1].len() == 64
+                && segments[index + 1].chars().all(|c| c.is_ascii_hexdigit())
+                && !segments[index + 2].is_empty()
+        })
+        .unwrap_or(false);
     if !is_buzz_repo_path {
         return Err("clone URL must point at a Buzz git repository".into());
     }
     Ok(())
 }
 
+pub(crate) fn clone_url_owner(clone_url: &str) -> Option<String> {
+    let parsed = Url::parse(clone_url).ok()?;
+    let segments = parsed
+        .path_segments()?
+        .filter(|segment| !segment.is_empty())
+        .collect::<Vec<_>>();
+    let index = segments.iter().rposition(|segment| *segment == "git")?;
+    (segments.len() == index + 3).then(|| segments[index + 1].to_ascii_lowercase())
+}
+
+pub(crate) fn validate_workspace_clone_url(
+    clone_url: &str,
+    state: &AppState,
+) -> Result<(), String> {
+    let relay_base = crate::relay::relay_api_base_url_with_override(state);
+    validate_clone_url_against_relay(clone_url, &relay_base)
+}
+
+fn validate_clone_url_against_relay(clone_url: &str, relay_base: &str) -> Result<(), String> {
+    validate_clone_url(clone_url)?;
+    let clone = Url::parse(clone_url).map_err(|error| format!("invalid clone URL: {error}"))?;
+    let relay = Url::parse(relay_base)
+        .map_err(|error| format!("configured relay URL is invalid: {error}"))?;
+    if clone.scheme() != relay.scheme()
+        || clone.host_str() != relay.host_str()
+        || clone.port_or_known_default() != relay.port_or_known_default()
+    {
+        return Err("clone URL must use the active workspace relay".into());
+    }
+    let relay_path = relay.path().trim_end_matches('/');
+    if !relay_path.is_empty() && !clone.path().starts_with(&format!("{relay_path}/")) {
+        return Err("clone URL must use the active workspace relay path".into());
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
-    use super::{clean_branch, validate_clone_url};
+    use super::{
+        clean_branch, git_needs_credentials, git_subcommand, validate_clone_url,
+        validate_clone_url_against_relay,
+    };
+
+    #[test]
+    fn git_subcommand_skips_global_config_options() {
+        assert_eq!(
+            git_subcommand(&[
+                "-c",
+                "user.name=Buzz User",
+                "-c",
+                "user.email=user@example.com",
+                "merge",
+                "HEAD",
+            ]),
+            Some("merge")
+        );
+        assert_eq!(
+            git_subcommand(&["--config=credential.useHttpPath=true", "fetch", "origin"]),
+            Some("fetch")
+        );
+    }
+
+    #[test]
+    fn remote_and_promisor_operations_receive_credentials() {
+        assert!(git_needs_credentials(&["fetch", "origin"]));
+        assert!(git_needs_credentials(&[
+            "-c",
+            "user.name=Buzz User",
+            "merge",
+            "HEAD"
+        ]));
+        assert!(!git_needs_credentials(&["rev-parse", "HEAD"]));
+    }
 
     #[test]
     fn clean_branch_accepts_plain_and_prefixed_names() {
@@ -220,5 +355,26 @@ mod tests {
         assert!(validate_clone_url("https://relay.example/git/short/repo").is_err());
         assert!(validate_clone_url("https://evil.example/has/git/inpath").is_err());
         assert!(validate_clone_url(&format!("ssh://relay.example/git/{owner}/repo")).is_err());
+        assert!(validate_clone_url(&format!(
+            "https://relay.example/git/{owner}/repo/unexpected"
+        ))
+        .is_err());
+    }
+
+    #[test]
+    fn workspace_clone_url_requires_exact_relay_origin_and_prefix() {
+        let owner = "a".repeat(64);
+        let valid = format!("https://relay.example/prefix/git/{owner}/repo");
+        assert!(validate_clone_url_against_relay(&valid, "https://relay.example/prefix").is_ok());
+        assert!(validate_clone_url_against_relay(&valid, "http://relay.example/prefix").is_err());
+        assert!(
+            validate_clone_url_against_relay(&valid, "https://relay.example:8443/prefix").is_err()
+        );
+        assert!(validate_clone_url_against_relay(&valid, "https://relay.example/other").is_err());
+        assert!(validate_clone_url_against_relay(
+            &format!("https://evil.example/prefix/git/{owner}/repo"),
+            "https://relay.example/prefix",
+        )
+        .is_err());
     }
 }
diff --git a/desktop/src-tauri/src/commands/project_git_workflow.rs b/desktop/src-tauri/src/commands/project_git_workflow.rs
new file mode 100644
index 0000000000..8763946e4c
--- /dev/null
+++ b/desktop/src-tauri/src/commands/project_git_workflow.rs
@@ -0,0 +1,696 @@
+//! Local clone and pull-request merge commands for the Projects workflow.
+
+use super::project_git::{first_output_line, normalize_branch_option};
+use super::project_git_diff::clean_commit;
+use super::project_git_exec::{
+    build_git_auth_config, build_git_auth_config_for_keys, clone_url_owner, run_git,
+    validate_clone_url, validate_workspace_clone_url, GitAuthConfig,
+};
+use super::project_repo_paths::{
+    canonical_repos_roots, canonicalize_repos_root, default_repos_root_candidates,
+    find_local_repo_dir, local_repo_candidates,
+};
+use crate::app_state::AppState;
+use crate::managed_agents::{load_managed_agents, spawn_key_refusal};
+use crate::relay::submit_signed_event_with_keys;
+use nostr::{Event, EventBuilder, JsonUtil, Keys, Kind, Tag, Timestamp};
+use serde::{Deserialize, Serialize};
+use tauri::{AppHandle, State};
+
+#[derive(Serialize)]
+pub struct ProjectRepoCloneResult {
+    pub path: String,
+    pub cloned: bool,
+    pub message: String,
+}
+
+#[derive(Serialize)]
+pub struct ProjectRepoMergeResult {
+    pub message: String,
+    pub merge_commit: String,
+    pub status_event: String,
+    pub status_publication_error: Option<String>,
+}
+
+struct ProjectRepoMergeGitResult {
+    message: String,
+    merge_commit: String,
+}
+
+/// Validated repository and pull-request metadata for a native merge.
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectPullRequestMergeInput {
+    target_clone_url: String,
+    source_clone_url: String,
+    target_owner: String,
+    repo_address: String,
+    pull_request_id: String,
+    pull_request_author: String,
+    status_created_at: u64,
+    target_branch: String,
+    source_branch: String,
+    expected_commit: String,
+}
+
+/// Repository-scoped metadata for an agent-signed review request.
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectPullRequestReviewRequestInput {
+    target_owner: String,
+    repo_address: String,
+    pull_request_id: String,
+    reviewers: Vec<String>,
+    reviewer_label: String,
+}
+
+/// A previously signed merged-status event that needs publishing again.
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProjectPullRequestMergedStatusInput {
+    target_owner: String,
+    status_event: String,
+}
+
+fn normalize_commit(value: &str) -> Option<String> {
+    clean_commit(Some(value.trim().to_ascii_lowercase()))
+}
+
+fn normalize_event_id(value: &str) -> Option<String> {
+    let value = value.trim().to_ascii_lowercase();
+    (value.len() == 64 && value.chars().all(|c| c.is_ascii_hexdigit())).then_some(value)
+}
+
+struct ProjectOwnerIdentity {
+    keys: Keys,
+    auth_tag: Option<String>,
+}
+
+fn project_owner_identity(
+    app: &AppHandle,
+    state: &AppState,
+    target_owner: &str,
+) -> Result<ProjectOwnerIdentity, String> {
+    let viewer_keys = state.signing_keys()?;
+    if viewer_keys.public_key().to_hex() == target_owner {
+        return Ok(ProjectOwnerIdentity {
+            keys: viewer_keys,
+            auth_tag: None,
+        });
+    }
+
+    let _store_guard = state
+        .managed_agents_store_lock
+        .lock()
+        .map_err(|error| error.to_string())?;
+    let records = load_managed_agents(app)?;
+    let record = records
+        .iter()
+        .find(|record| record.pubkey.eq_ignore_ascii_case(target_owner))
+        .ok_or_else(|| {
+            "Only the repository owner or the owner of its managed agent can merge pull requests."
+                .to_string()
+        })?;
+    if let Some(error) = spawn_key_refusal(record) {
+        return Err(error);
+    }
+    let keys = Keys::parse(&record.private_key_nsec)
+        .map_err(|error| format!("managed agent signing key is invalid: {error}"))?;
+    if keys.public_key().to_hex() != target_owner {
+        return Err("Managed agent key does not match the repository owner.".to_string());
+    }
+    Ok(ProjectOwnerIdentity {
+        keys,
+        auth_tag: record.auth_tag.clone(),
+    })
+}
+
+fn validate_repo_address(repo_address: &str, owner: &str) -> Result<(), String> {
+    let prefix = format!("30617:{owner}:");
+    if repo_address.strip_prefix(&prefix).is_none_or(str::is_empty) {
+        return Err("Repository address does not match the repository owner.".to_string());
+    }
+    Ok(())
+}
+
+fn validate_merge_status_metadata(
+    repo_address: &str,
+    owner: &str,
+    pull_request_id: &str,
+    pull_request_author: &str,
+) -> Result<(String, String), String> {
+    validate_repo_address(repo_address, owner)?;
+    let pull_request_id = normalize_event_id(pull_request_id)
+        .ok_or_else(|| "Invalid pull request event ID.".to_string())?;
+    let pull_request_author = normalize_event_id(pull_request_author)
+        .ok_or_else(|| "Invalid pull request author.".to_string())?;
+    Ok((pull_request_id, pull_request_author))
+}
+
+fn build_merged_status_event(
+    keys: &Keys,
+    repo_address: &str,
+    pull_request_id: &str,
+    pull_request_author: &str,
+    merge_commit: &str,
+    created_at: u64,
+) -> Result<String, String> {
+    let owner = keys.public_key().to_hex();
+    let (pull_request_id, pull_request_author) =
+        validate_merge_status_metadata(repo_address, &owner, pull_request_id, pull_request_author)?;
+    let merge_commit =
+        normalize_commit(merge_commit).ok_or_else(|| "Invalid merge commit.".to_string())?;
+    let created_at = created_at.max(Timestamp::now().as_secs());
+
+    let mut raw_tags = vec![
+        vec!["e", pull_request_id.as_str(), "", "root"],
+        vec!["a", repo_address],
+        vec!["p", owner.as_str()],
+    ];
+    if pull_request_author != owner {
+        raw_tags.push(vec!["p", pull_request_author.as_str()]);
+    }
+    raw_tags.extend([
+        vec!["merge-commit", merge_commit.as_str()],
+        vec!["r", merge_commit.as_str()],
+    ]);
+    let tags = raw_tags
+        .into_iter()
+        .map(Tag::parse)
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|error| format!("build merged status tags: {error}"))?;
+    EventBuilder::new(Kind::Custom(1631), "")
+        .tags(tags)
+        .custom_created_at(Timestamp::from(created_at))
+        .sign_with_keys(keys)
+        .map(|event| event.as_json())
+        .map_err(|error| format!("sign merged pull request status: {error}"))
+}
+
+fn build_review_request_event(
+    keys: &Keys,
+    repo_address: &str,
+    pull_request_id: &str,
+    reviewers: &[String],
+    reviewer_label: &str,
+) -> Result<String, String> {
+    let owner = keys.public_key().to_hex();
+    validate_repo_address(repo_address, &owner)?;
+    let pull_request_id = normalize_event_id(pull_request_id)
+        .ok_or_else(|| "Invalid pull request event ID.".to_string())?;
+    if reviewers.is_empty() || reviewers.len() > 50 {
+        return Err("Select between 1 and 50 reviewers.".to_string());
+    }
+    let mut reviewers = reviewers
+        .iter()
+        .map(|reviewer| {
+            normalize_event_id(reviewer).ok_or_else(|| "Invalid reviewer pubkey.".to_string())
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    reviewers.sort();
+    reviewers.dedup();
+    let reviewer_label = reviewer_label.trim();
+    if reviewer_label.is_empty() || reviewer_label.chars().count() > 128 {
+        return Err("Reviewer label must be between 1 and 128 characters.".to_string());
+    }
+
+    let mut raw_tags = vec![
+        vec![
+            "e".to_string(),
+            pull_request_id,
+            String::new(),
+            "root".to_string(),
+        ],
+        vec!["a".to_string(), repo_address.to_string()],
+    ];
+    raw_tags.extend(
+        reviewers
+            .into_iter()
+            .map(|reviewer| vec!["p".to_string(), reviewer]),
+    );
+    raw_tags.push(vec!["t".to_string(), "review-request".to_string()]);
+    let tags = raw_tags
+        .into_iter()
+        .map(Tag::parse)
+        .collect::<Result<Vec<_>, _>>()
+        .map_err(|error| format!("build review request tags: {error}"))?;
+    EventBuilder::new(
+        Kind::TextNote,
+        format!("Requested a review from {reviewer_label}"),
+    )
+    .tags(tags)
+    .sign_with_keys(keys)
+    .map(|event| event.as_json())
+    .map_err(|error| format!("sign pull request review request: {error}"))
+}
+
+fn same_repository(left: &str, right: &str) -> bool {
+    left.trim()
+        .trim_end_matches('/')
+        .trim_end_matches(".git")
+        .eq_ignore_ascii_case(right.trim().trim_end_matches('/').trim_end_matches(".git"))
+}
+
+fn clone_destination_root(repos_dir: Option<&str>) -> Result<std::path::PathBuf, String> {
+    match canonical_repos_roots(repos_dir) {
+        Ok(roots) => roots
+            .into_iter()
+            .next()
+            .ok_or_else(|| "reposDir is not accessible".to_string()),
+        Err(error) => {
+            if repos_dir.is_some() {
+                return Err(error);
+            }
+            let root = default_repos_root_candidates()
+                .into_iter()
+                .next()
+                .ok_or(error)?;
+            std::fs::create_dir_all(&root).map_err(|error| format!("create repos dir: {error}"))?;
+            canonicalize_repos_root(root)
+        }
+    }
+}
+
+pub(crate) fn clone_project_repository_blocking(
+    repos_dir: Option<&str>,
+    project_dtag: &str,
+    clone_url: &str,
+    default_branch: Option<&str>,
+    auth: &GitAuthConfig,
+) -> Result<ProjectRepoCloneResult, String> {
+    validate_clone_url(clone_url)?;
+    let branch = normalize_branch_option(default_branch);
+    if let Some(repo_dir) = find_local_repo_dir(repos_dir, project_dtag, Some(clone_url))? {
+        return Ok(ProjectRepoCloneResult {
+            path: repo_dir.display().to_string(),
+            cloned: false,
+            message: "Repository is already cloned.".to_string(),
+        });
+    }
+
+    let repos_root = clone_destination_root(repos_dir)?;
+    let repo_name = local_repo_candidates(project_dtag, Some(clone_url))
+        .into_iter()
+        .next()
+        .ok_or_else(|| "Could not derive a directory name for the repository.".to_string())?;
+    let repo_dir = repos_root.join(repo_name);
+    if repo_dir.exists() {
+        return Err(format!(
+            "{} already exists but is not a git checkout.",
+            repo_dir.display()
+        ));
+    }
+    let repo_path = repo_dir
+        .to_str()
+        .ok_or_else(|| "repository path is not UTF-8".to_string())?;
+
+    let mut clone_args = vec!["clone"];
+    if let Some(ref branch) = branch {
+        clone_args.extend(["--branch", branch.as_str()]);
+    }
+    clone_args.extend(["--end-of-options", clone_url, repo_path]);
+    if let Err(error) = run_git(&clone_args, None, auth) {
+        if branch.is_none() {
+            return Err(error);
+        }
+        run_git(
+            &["clone", "--end-of-options", clone_url, repo_path],
+            None,
+            auth,
+        )?;
+    }
+
+    Ok(ProjectRepoCloneResult {
+        path: repo_dir.display().to_string(),
+        cloned: true,
+        message: format!("Cloned repository to {}.", repo_dir.display()),
+    })
+}
+
+#[tauri::command]
+pub async fn clone_project_repository(
+    repos_dir: Option<String>,
+    project_dtag: String,
+    clone_url: String,
+    default_branch: Option<String>,
+    state: State<'_, AppState>,
+) -> Result<ProjectRepoCloneResult, String> {
+    validate_workspace_clone_url(&clone_url, &state)?;
+    let auth = build_git_auth_config(&state)?;
+    tauri::async_runtime::spawn_blocking(move || {
+        clone_project_repository_blocking(
+            repos_dir.as_deref(),
+            &project_dtag,
+            &clone_url,
+            default_branch.as_deref(),
+            &auth,
+        )
+    })
+    .await
+    .map_err(|error| format!("repo clone task failed: {error}"))?
+}
+
+#[tauri::command]
+pub async fn sign_project_pull_request_review_request(
+    input: ProjectPullRequestReviewRequestInput,
+    app: AppHandle,
+    state: State<'_, AppState>,
+) -> Result<(), String> {
+    let target_owner = input.target_owner.trim().to_ascii_lowercase();
+    if normalize_event_id(&target_owner).is_none() {
+        return Err("Invalid target repository owner.".to_string());
+    }
+    let identity = project_owner_identity(&app, &state, &target_owner)?;
+    let event = Event::from_json(build_review_request_event(
+        &identity.keys,
+        &input.repo_address,
+        &input.pull_request_id,
+        &input.reviewers,
+        &input.reviewer_label,
+    )?)
+    .map_err(|error| format!("parse signed review request: {error}"))?;
+    submit_signed_event_with_keys(&event, &state, &identity.keys, identity.auth_tag.as_deref())
+        .await?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn publish_project_pull_request_merged_status(
+    input: ProjectPullRequestMergedStatusInput,
+    app: AppHandle,
+    state: State<'_, AppState>,
+) -> Result<(), String> {
+    let target_owner = input.target_owner.trim().to_ascii_lowercase();
+    if normalize_event_id(&target_owner).is_none() {
+        return Err("Invalid target repository owner.".to_string());
+    }
+    let event = Event::from_json(input.status_event)
+        .map_err(|error| format!("parse merged status event: {error}"))?;
+    if event.kind != Kind::Custom(1631)
+        || event.pubkey.to_hex() != target_owner
+        || event.verify().is_err()
+    {
+        return Err("Invalid merged pull request status event.".to_string());
+    }
+    let identity = project_owner_identity(&app, &state, &target_owner)?;
+    submit_signed_event_with_keys(&event, &state, &identity.keys, identity.auth_tag.as_deref())
+        .await?;
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn merge_project_pull_request(
+    input: ProjectPullRequestMergeInput,
+    app: AppHandle,
+    state: State<'_, AppState>,
+) -> Result<ProjectRepoMergeResult, String> {
+    let ProjectPullRequestMergeInput {
+        target_clone_url,
+        source_clone_url,
+        target_owner,
+        repo_address,
+        pull_request_id,
+        pull_request_author,
+        status_created_at,
+        target_branch,
+        source_branch,
+        expected_commit,
+    } = input;
+    validate_workspace_clone_url(&target_clone_url, &state)?;
+    validate_workspace_clone_url(&source_clone_url, &state)?;
+    let target_owner = target_owner.trim().to_ascii_lowercase();
+    if target_owner.len() != 64 || !target_owner.chars().all(|c| c.is_ascii_hexdigit()) {
+        return Err("Invalid target repository owner.".to_string());
+    }
+    if clone_url_owner(&target_clone_url).as_deref() != Some(target_owner.as_str()) {
+        return Err("Target clone URL does not match the repository owner.".to_string());
+    }
+    let owner_identity = project_owner_identity(&app, &state, &target_owner)?;
+    let merger_pubkey = owner_identity.keys.public_key().to_hex();
+    let target_branch = normalize_branch_option(Some(&target_branch))
+        .ok_or_else(|| "Invalid target branch.".to_string())?;
+    let source_branch = normalize_branch_option(Some(&source_branch))
+        .ok_or_else(|| "Invalid source branch.".to_string())?;
+    if target_branch == source_branch && same_repository(&target_clone_url, &source_clone_url) {
+        return Err("Source and target branches must be different.".to_string());
+    }
+    let expected_commit = normalize_commit(&expected_commit)
+        .ok_or_else(|| "Invalid pull request commit.".to_string())?;
+    let (pull_request_id, pull_request_author) = validate_merge_status_metadata(
+        &repo_address,
+        &merger_pubkey,
+        &pull_request_id,
+        &pull_request_author,
+    )?;
+    let auth = build_git_auth_config_for_keys(&owner_identity.keys)?;
+
+    let git_result = tauri::async_runtime::spawn_blocking(move || {
+        let temp_dir = tempfile::tempdir().map_err(|error| format!("create temp dir: {error}"))?;
+        let repo_dir = temp_dir.path().join("repo");
+        let repo_path = repo_dir
+            .to_str()
+            .ok_or_else(|| "temporary repository path is not UTF-8".to_string())?;
+        run_git(
+            &[
+                "clone",
+                "--filter=blob:none",
+                "--no-tags",
+                "--branch",
+                target_branch.as_str(),
+                "--single-branch",
+                "--end-of-options",
+                target_clone_url.as_str(),
+                repo_path,
+            ],
+            None,
+            &auth,
+        )?;
+        run_git(
+            &[
+                "fetch",
+                "--quiet",
+                "--end-of-options",
+                source_clone_url.as_str(),
+                source_branch.as_str(),
+            ],
+            Some(&repo_dir),
+            &auth,
+        )?;
+        let source_head = run_git(&["rev-parse", "FETCH_HEAD"], Some(&repo_dir), &auth)
+            .ok()
+            .and_then(|output| first_output_line(&output))
+            .ok_or_else(|| "Could not resolve the pull request branch.".to_string())?;
+        if source_head.to_ascii_lowercase() != expected_commit {
+            return Err(
+                "The pull request branch changed. Refresh the pull request before merging."
+                    .to_string(),
+            );
+        }
+
+        let merge_email = format!("{merger_pubkey}@users.noreply.buzz");
+        run_git(
+            &[
+                "-c",
+                "user.name=Buzz User",
+                "-c",
+                format!("user.email={merge_email}").as_str(),
+                "merge",
+                "--no-edit",
+                "--end-of-options",
+                expected_commit.as_str(),
+            ],
+            Some(&repo_dir),
+            &auth,
+        )
+        .map_err(|error| format!("Pull request cannot be merged cleanly: {error}"))?;
+        let merge_commit = run_git(&["rev-parse", "HEAD"], Some(&repo_dir), &auth)
+            .ok()
+            .and_then(|output| first_output_line(&output))
+            .ok_or_else(|| "Could not resolve the merge commit.".to_string())?;
+        run_git(
+            &[
+                "push",
+                "--end-of-options",
+                "origin",
+                format!("HEAD:{target_branch}").as_str(),
+            ],
+            Some(&repo_dir),
+            &auth,
+        )?;
+
+        Ok(ProjectRepoMergeGitResult {
+            message: format!("Merged {source_branch} into {target_branch}."),
+            merge_commit,
+        })
+    })
+    .await
+    .map_err(|error| format!("pull request merge task failed: {error}"))??;
+    let status_event = build_merged_status_event(
+        &owner_identity.keys,
+        &repo_address,
+        &pull_request_id,
+        &pull_request_author,
+        &git_result.merge_commit,
+        status_created_at,
+    )?;
+    let signed_status = Event::from_json(&status_event)
+        .map_err(|error| format!("parse signed merged status: {error}"))?;
+    let status_publication_error = submit_signed_event_with_keys(
+        &signed_status,
+        &state,
+        &owner_identity.keys,
+        owner_identity.auth_tag.as_deref(),
+    )
+    .await
+    .err();
+    Ok(ProjectRepoMergeResult {
+        message: git_result.message,
+        merge_commit: git_result.merge_commit,
+        status_event,
+        status_publication_error,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        build_merged_status_event, build_review_request_event, normalize_commit, same_repository,
+        validate_merge_status_metadata,
+    };
+    use nostr::{Event, JsonUtil, Keys, Timestamp};
+
+    #[test]
+    fn normalize_commit_accepts_sha1_and_sha256_hex() {
+        assert_eq!(normalize_commit(&"A".repeat(40)), Some("a".repeat(40)));
+        assert_eq!(normalize_commit(&"B".repeat(64)), Some("b".repeat(64)));
+    }
+
+    #[test]
+    fn normalize_commit_rejects_invalid_values() {
+        assert_eq!(normalize_commit("abc"), None);
+        assert_eq!(normalize_commit(&"z".repeat(40)), None);
+    }
+
+    #[test]
+    fn repository_comparison_normalizes_git_suffix_and_trailing_slash() {
+        assert!(same_repository(
+            "https://relay.example/git/owner/repo.git",
+            "https://relay.example/git/owner/repo/"
+        ));
+        assert!(!same_repository(
+            "https://relay.example/git/owner/repo",
+            "https://relay.example/git/fork/repo"
+        ));
+    }
+
+    #[test]
+    fn merged_status_is_signed_by_repository_owner() {
+        let keys = Keys::generate();
+        let owner = keys.public_key().to_hex();
+        let pull_request_id = "d".repeat(64);
+        let pull_request_author = "b".repeat(64);
+        let merge_commit = "e".repeat(40);
+        let repo_address = format!("30617:{owner}:buzz");
+        let before = Timestamp::now().as_secs();
+        let event = Event::from_json(
+            build_merged_status_event(
+                &keys,
+                &repo_address,
+                &pull_request_id,
+                &pull_request_author,
+                &merge_commit,
+                123,
+            )
+            .unwrap(),
+        )
+        .unwrap();
+
+        assert_eq!(event.pubkey, keys.public_key());
+        assert_eq!(event.kind.as_u16(), 1631);
+        assert!(event.created_at.as_secs() >= before);
+        assert!(event
+            .tags
+            .iter()
+            .any(|tag| tag.as_slice() == ["merge-commit", merge_commit.as_str()]));
+        assert!(event.verify().is_ok());
+    }
+
+    #[test]
+    fn merged_status_preserves_a_newer_requested_timestamp() {
+        let keys = Keys::generate();
+        let owner = keys.public_key().to_hex();
+        let requested = Timestamp::now().as_secs() + 10;
+        let event = Event::from_json(
+            build_merged_status_event(
+                &keys,
+                &format!("30617:{owner}:buzz"),
+                &"d".repeat(64),
+                &"b".repeat(64),
+                &"e".repeat(40),
+                requested,
+            )
+            .unwrap(),
+        )
+        .unwrap();
+
+        assert_eq!(event.created_at.as_secs(), requested);
+    }
+
+    #[test]
+    fn merge_status_metadata_is_rejected_before_git_work() {
+        let owner = "a".repeat(64);
+        assert!(validate_merge_status_metadata(
+            &format!("30617:{}:buzz", "b".repeat(64)),
+            &owner,
+            &"d".repeat(64),
+            &"e".repeat(64),
+        )
+        .is_err());
+        assert!(validate_merge_status_metadata(
+            &format!("30617:{owner}:buzz"),
+            &owner,
+            "not-an-event-id",
+            &"e".repeat(64),
+        )
+        .is_err());
+        assert!(validate_merge_status_metadata(
+            &format!("30617:{owner}:buzz"),
+            &owner,
+            &"d".repeat(64),
+            "not-an-author",
+        )
+        .is_err());
+    }
+
+    #[test]
+    fn review_request_is_signed_by_repository_owner() {
+        let keys = Keys::generate();
+        let owner = keys.public_key().to_hex();
+        let reviewer = "b".repeat(64);
+        let repo_address = format!("30617:{owner}:buzz");
+        let event = Event::from_json(
+            build_review_request_event(
+                &keys,
+                &repo_address,
+                &"d".repeat(64),
+                std::slice::from_ref(&reviewer),
+                "Bob",
+            )
+            .unwrap(),
+        )
+        .unwrap();
+
+        assert_eq!(event.pubkey, keys.public_key());
+        assert_eq!(event.kind, nostr::Kind::TextNote);
+        assert_eq!(event.content, "Requested a review from Bob");
+        assert!(event
+            .tags
+            .iter()
+            .any(|tag| tag.as_slice() == ["p", reviewer.as_str()]));
+        assert!(event
+            .tags
+            .iter()
+            .any(|tag| tag.as_slice() == ["t", "review-request"]));
+        assert!(event.verify().is_ok());
+    }
+}
diff --git a/desktop/src-tauri/src/commands/project_repo_paths.rs b/desktop/src-tauri/src/commands/project_repo_paths.rs
index 69cb2465c3..4193327c01 100644
--- a/desktop/src-tauri/src/commands/project_repo_paths.rs
+++ b/desktop/src-tauri/src/commands/project_repo_paths.rs
@@ -25,11 +25,89 @@ fn clone_url_repo_name(clone_url: &str) -> Option<String> {
     local_repo_name_candidate(last_segment)
 }
 
+fn clone_url_owner_repo_name(clone_url: &str) -> Option<String> {
+    let parsed = Url::parse(clone_url).ok()?;
+    let parts = parsed
+        .path_segments()?
+        .filter(|part| !part.is_empty())
+        .collect::<Vec<_>>();
+    let [.., owner, repo] = parts.as_slice() else {
+        return None;
+    };
+    local_repo_name_candidate(&format!(
+        "{}--{}",
+        local_repo_name_candidate(owner)?,
+        local_repo_name_candidate(repo)?
+    ))
+}
+
+fn normalized_clone_url(value: &str) -> &str {
+    value.trim().trim_end_matches('/').trim_end_matches(".git")
+}
+
+fn checkout_git_config(
+    repo_dir: &std::path::Path,
+    repos_root: &std::path::Path,
+) -> Option<std::path::PathBuf> {
+    let dot_git = repo_dir.join(".git");
+    let git_dir = if dot_git.is_dir() {
+        dot_git
+    } else {
+        let pointer = std::fs::read_to_string(dot_git).ok()?;
+        let git_dir = std::path::PathBuf::from(pointer.trim().strip_prefix("gitdir:")?.trim());
+        if git_dir.is_absolute() {
+            git_dir
+        } else {
+            repo_dir.join(git_dir)
+        }
+    };
+    let git_dir = git_dir.canonicalize().ok()?;
+    if !git_dir.starts_with(repos_root) {
+        return None;
+    }
+    let config = git_dir.join("config").canonicalize().ok()?;
+    config.starts_with(repos_root).then_some(config)
+}
+
+fn checkout_origin_matches(
+    repo_dir: &std::path::Path,
+    repos_root: &std::path::Path,
+    clone_url: &str,
+) -> bool {
+    let Some(config_path) = checkout_git_config(repo_dir, repos_root) else {
+        return false;
+    };
+    let Ok(config) = std::fs::read_to_string(config_path) else {
+        return false;
+    };
+    let mut in_origin = false;
+    for line in config.lines() {
+        let line = line.trim();
+        if line.starts_with('[') {
+            in_origin = line == r#"[remote "origin"]"#;
+            continue;
+        }
+        if in_origin {
+            if let Some((key, value)) = line.split_once('=') {
+                if key.trim() == "url" {
+                    return normalized_clone_url(value) == normalized_clone_url(clone_url);
+                }
+            }
+        }
+    }
+    false
+}
+
 pub(crate) fn local_repo_candidates(project_dtag: &str, clone_url: Option<&str>) -> Vec<String> {
     let mut candidates = Vec::new();
-    if let Some(candidate) = local_repo_name_candidate(project_dtag) {
+    if let Some(candidate) = clone_url.and_then(clone_url_owner_repo_name) {
         candidates.push(candidate);
     }
+    if let Some(candidate) = local_repo_name_candidate(project_dtag) {
+        if !candidates.iter().any(|existing| existing == &candidate) {
+            candidates.push(candidate);
+        }
+    }
     if let Some(candidate) = clone_url.and_then(clone_url_repo_name) {
         if !candidates.iter().any(|existing| existing == &candidate) {
             candidates.push(candidate);
@@ -54,7 +132,11 @@ pub(crate) fn find_local_repo_dir(
             if !candidate_path.starts_with(&repos_root) || !candidate_path.is_dir() {
                 continue;
             }
-            if candidate_path.join(".git").exists() {
+            if candidate_path.join(".git").exists()
+                && clone_url
+                    .map(|url| checkout_origin_matches(&candidate_path, &repos_root, url))
+                    .unwrap_or(true)
+            {
                 return Ok(Some(candidate_path));
             }
         }
diff --git a/desktop/src-tauri/src/commands/project_terminal.rs b/desktop/src-tauri/src/commands/project_terminal.rs
index ee3967b8ff..24bc138407 100644
--- a/desktop/src-tauri/src/commands/project_terminal.rs
+++ b/desktop/src-tauri/src/commands/project_terminal.rs
@@ -7,12 +7,9 @@ use tauri::State;
 
 use crate::app_state::AppState;
 
-use super::project_git::normalize_branch_option;
-use super::project_git_exec::{build_git_auth_config, run_git, validate_clone_url};
-use super::project_repo_paths::{
-    canonical_repos_roots, canonicalize_repos_root, default_repos_root_candidates,
-    find_local_repo_dir, local_repo_candidates,
-};
+use super::project_git_exec::{build_git_auth_config, validate_workspace_clone_url};
+use super::project_git_workflow::clone_project_repository_blocking;
+use super::project_repo_paths::find_local_repo_dir;
 
 /// Result of [`open_project_terminal`]: where the terminal opened and
 /// whether a fresh clone was made to get there.
@@ -68,29 +65,6 @@ fn launch_terminal_at(path: &std::path::Path) -> Result<(), String> {
     Ok(())
 }
 
-/// Resolves the repos root a fresh clone should land in, creating the
-/// default root when no explicit `reposDir` is configured and none of the
-/// default candidates exist yet.
-fn clone_destination_root(repos_dir: Option<&str>) -> Result<std::path::PathBuf, String> {
-    match canonical_repos_roots(repos_dir) {
-        Ok(roots) => roots
-            .into_iter()
-            .next()
-            .ok_or_else(|| "reposDir is not accessible".to_string()),
-        Err(error) => {
-            if repos_dir.is_some() {
-                return Err(error);
-            }
-            let root = default_repos_root_candidates()
-                .into_iter()
-                .next()
-                .ok_or(error)?;
-            std::fs::create_dir_all(&root).map_err(|error| format!("create repos dir: {error}"))?;
-            canonicalize_repos_root(root)
-        }
-    }
-}
-
 /// Opens the OS terminal at the project's local checkout. When there is no
 /// local checkout yet, clones the repository from `clone_url` (authenticated
 /// with the identity key, same as push/snapshot) into the repos dir first,
@@ -103,11 +77,12 @@ pub async fn open_project_terminal(
     default_branch: Option<String>,
     state: State<'_, AppState>,
 ) -> Result<ProjectTerminalResult, String> {
-    // Auth is only needed for the clone path — a missing git binary must not
-    // block opening a terminal at an existing checkout.
+    if let Some(clone_url) = clone_url.as_deref() {
+        validate_workspace_clone_url(clone_url, &state)?;
+    }
+    // Auth is only needed for the clone path — keep the result outside the
+    // blocking task so it owns no borrowed Tauri state.
     let auth = build_git_auth_config(&state);
-    let branch = normalize_branch_option(default_branch.as_deref());
-
     tauri::async_runtime::spawn_blocking(move || {
         // An inaccessible repos root (fresh machine, nothing cloned yet) is
         // not fatal here — the clone path below creates the default root. A
@@ -129,45 +104,19 @@ pub async fn open_project_terminal(
             .map(str::trim)
             .filter(|value| !value.is_empty())
             .ok_or_else(|| "No local checkout and no clone URL available.".to_string())?;
-        validate_clone_url(clone_url)?;
         let auth = auth?;
-
-        let repos_root = clone_destination_root(repos_dir.as_deref())?;
-        let repo_name = local_repo_candidates(&project_dtag, Some(clone_url))
-            .into_iter()
-            .next()
-            .ok_or_else(|| "Could not derive a directory name for the repository.".to_string())?;
-        let repo_dir = repos_root.join(&repo_name);
-        if repo_dir.exists() {
-            return Err(format!(
-                "{} already exists but is not a git checkout.",
-                repo_dir.display()
-            ));
-        }
-        let repo_path = repo_dir
-            .to_str()
-            .ok_or_else(|| "repository path is not UTF-8".to_string())?;
-
-        let mut clone_args = vec!["clone"];
-        if let Some(ref branch) = branch {
-            clone_args.push("--branch");
-            clone_args.push(branch.as_str());
-        }
-        clone_args.push(clone_url);
-        clone_args.push(repo_path);
-        if let Err(error) = run_git(&clone_args, None, &auth) {
-            // The requested branch may not exist on the remote — retry with
-            // the remote's default branch before giving up.
-            if branch.is_none() {
-                return Err(error);
-            }
-            run_git(&["clone", clone_url, repo_path], None, &auth)?;
-        }
-
+        let clone_result = clone_project_repository_blocking(
+            repos_dir.as_deref(),
+            &project_dtag,
+            clone_url,
+            default_branch.as_deref(),
+            &auth,
+        )?;
+        let repo_dir = std::path::PathBuf::from(&clone_result.path);
         launch_terminal_at(&repo_dir)?;
         Ok(ProjectTerminalResult {
-            path: repo_dir.display().to_string(),
-            cloned: true,
+            path: clone_result.path,
+            cloned: clone_result.cloned,
         })
     })
     .await
diff --git a/desktop/src-tauri/src/commands/window_chrome.rs b/desktop/src-tauri/src/commands/window_chrome.rs
new file mode 100644
index 0000000000..5dba9dd72e
--- /dev/null
+++ b/desktop/src-tauri/src/commands/window_chrome.rs
@@ -0,0 +1,101 @@
+/// Performs the platform's default sidebar alignment haptic when available.
+#[tauri::command]
+pub fn perform_sidebar_default_haptic() {
+    #[cfg(target_os = "macos")]
+    {
+        use objc2_app_kit::{
+            NSHapticFeedbackManager, NSHapticFeedbackPattern, NSHapticFeedbackPerformanceTime,
+            NSHapticFeedbackPerformer,
+        };
+
+        NSHapticFeedbackManager::defaultPerformer().performFeedbackPattern_performanceTime(
+            NSHapticFeedbackPattern::Alignment,
+            NSHapticFeedbackPerformanceTime::Now,
+        );
+    }
+}
+
+/// Performs the window action matching the macOS "double-click a window's
+/// title bar to" preference (`AppleActionOnDoubleClick`).
+///
+/// macOS values are `Minimize`, `Maximize` (default when unset), `Fill`, or
+/// `None`.
+/// The desktop app uses a web-based title-bar drag region, so the frontend
+/// forwards double-clicks here and suppresses Tauri's injected drag-region
+/// handler, whose default macOS path hardcodes maximize.
+///
+/// For `Fill`, resize to the current monitor work area instead of using
+/// Tauri's maximize path, which maps to macOS zoom for titled, resizable
+/// windows.
+///
+/// On non-macOS platforms this always toggles maximize (the historical
+/// behavior).
+#[tauri::command]
+pub fn title_bar_double_click(window: tauri::Window) {
+    #[cfg(target_os = "macos")]
+    {
+        let action = {
+            let output = std::process::Command::new("defaults")
+                .args(["read", "-g", "AppleActionOnDoubleClick"])
+                .output();
+            match output {
+                Ok(output) if output.status.success() => {
+                    String::from_utf8_lossy(&output.stdout).trim().to_string()
+                }
+                _ => "Maximize".to_string(),
+            }
+        };
+
+        match action.as_str() {
+            "None" => {}
+            "Minimize" => {
+                let _ = window.minimize();
+            }
+            "Fill" => {
+                fill_window(&window);
+            }
+            // "Maximize" or any unexpected value.
+            _ => {
+                toggle_maximize(&window);
+            }
+        }
+    }
+
+    #[cfg(not(target_os = "macos"))]
+    {
+        toggle_maximize(&window);
+    }
+}
+
+/// Fills the current display work area, excluding system UI like the menu bar
+/// and Dock.
+#[cfg(target_os = "macos")]
+fn fill_window(window: &tauri::Window) {
+    match window.current_monitor() {
+        Ok(Some(monitor)) => {
+            if window.is_maximized().unwrap_or(false) {
+                let _ = window.unmaximize();
+            }
+
+            let work_area = monitor.work_area();
+            let _ = window.set_position(work_area.position);
+            let _ = window.set_size(work_area.size);
+        }
+        _ => {
+            let _ = window.maximize();
+        }
+    }
+}
+
+/// Toggles the window between maximized and its previous size, matching the
+/// historical double-click behavior.
+fn toggle_maximize(window: &tauri::Window) {
+    match window.is_maximized() {
+        Ok(true) => {
+            let _ = window.unmaximize();
+        }
+        _ => {
+            let _ = window.maximize();
+        }
+    }
+}
diff --git a/desktop/src-tauri/src/lib.rs b/desktop/src-tauri/src/lib.rs
index e2dcac24ff..7ff0965960 100644
--- a/desktop/src-tauri/src/lib.rs
+++ b/desktop/src-tauri/src/lib.rs
@@ -63,106 +63,6 @@ use tauri_plugin_window_state::StateFlags;
 
 #[cfg(target_os = "macos")]
 const INITIAL_RENDER_READY_EVENT: &str = "initial-render-ready";
-#[tauri::command]
-fn perform_sidebar_default_haptic() {
-    #[cfg(target_os = "macos")]
-    {
-        use objc2_app_kit::{
-            NSHapticFeedbackManager, NSHapticFeedbackPattern, NSHapticFeedbackPerformanceTime,
-            NSHapticFeedbackPerformer,
-        };
-
-        NSHapticFeedbackManager::defaultPerformer().performFeedbackPattern_performanceTime(
-            NSHapticFeedbackPattern::Alignment,
-            NSHapticFeedbackPerformanceTime::Now,
-        );
-    }
-}
-
-/// Performs the window action matching the macOS "double-click a window's
-/// title bar to" preference (`AppleActionOnDoubleClick`).
-///
-/// macOS values are `Minimize`, `Maximize` (default when unset), `Fill`, or
-/// `None`.
-/// The desktop app uses a web-based title-bar drag region, so the frontend
-/// forwards double-clicks here and suppresses Tauri's injected drag-region
-/// handler, whose default macOS path hardcodes maximize.
-///
-/// For `Fill`, resize to the current monitor work area instead of using
-/// Tauri's maximize path, which maps to macOS zoom for titled, resizable
-/// windows.
-///
-/// On non-macOS platforms this always toggles maximize (the historical
-/// behavior).
-#[tauri::command]
-fn title_bar_double_click(window: tauri::Window) {
-    #[cfg(target_os = "macos")]
-    {
-        let action = {
-            let output = std::process::Command::new("defaults")
-                .args(["read", "-g", "AppleActionOnDoubleClick"])
-                .output();
-            match output {
-                Ok(output) if output.status.success() => {
-                    String::from_utf8_lossy(&output.stdout).trim().to_string()
-                }
-                _ => "Maximize".to_string(),
-            }
-        };
-
-        match action.as_str() {
-            "None" => {}
-            "Minimize" => {
-                let _ = window.minimize();
-            }
-            "Fill" => {
-                fill_window(&window);
-            }
-            // "Maximize" or any unexpected value.
-            _ => {
-                toggle_maximize(&window);
-            }
-        }
-    }
-
-    #[cfg(not(target_os = "macos"))]
-    {
-        toggle_maximize(&window);
-    }
-}
-
-/// Fills the current display work area, excluding system UI like the menu bar
-/// and Dock.
-#[cfg(target_os = "macos")]
-fn fill_window(window: &tauri::Window) {
-    match window.current_monitor() {
-        Ok(Some(monitor)) => {
-            if window.is_maximized().unwrap_or(false) {
-                let _ = window.unmaximize();
-            }
-
-            let work_area = monitor.work_area();
-            let _ = window.set_position(work_area.position);
-            let _ = window.set_size(work_area.size);
-        }
-        _ => {
-            let _ = window.maximize();
-        }
-    }
-}
-
-/// Toggles the window between maximized and its previous size, matching the
-/// historical double-click behavior.
-fn toggle_maximize(window: &tauri::Window) {
-    match window.is_maximized() {
-        Ok(true) => {
-            let _ = window.unmaximize();
-        }
-        _ => {
-            let _ = window.maximize();
-        }
-    }
-}
 
 fn reveal_initial_window<R: tauri::Runtime>(window: &tauri::Window<R>) {
     if let Err(error) = window.show() {
@@ -772,8 +672,12 @@ pub fn run() {
             get_project_local_repo_snapshot,
             get_project_repo_sync_status,
             list_project_local_repositories,
+            clone_project_repository,
             push_project_local_repository,
             pull_project_local_repository,
+            sign_project_pull_request_review_request,
+            publish_project_pull_request_merged_status,
+            merge_project_pull_request,
             open_project_terminal,
             search_users,
             get_presence,
diff --git a/desktop/src-tauri/src/relay.rs b/desktop/src-tauri/src/relay.rs
index 646c19913a..0c253ed0ae 100644
--- a/desktop/src-tauri/src/relay.rs
+++ b/desktop/src-tauri/src/relay.rs
@@ -570,10 +570,23 @@ pub async fn submit_event_with_keys(
     keys: &Keys,
     auth_tag: Option<&str>,
 ) -> Result<SubmitEventResponse, String> {
-    let url = format!("{}/events", relay_api_base_url_with_override(state));
     let event = builder
         .sign_with_keys(keys)
         .map_err(|e| format!("failed to sign event: {e}"))?;
+    submit_signed_event_with_keys(&event, state, keys, auth_tag).await
+}
+
+/// POST an already-signed event using the same explicit identity for NIP-98.
+pub async fn submit_signed_event_with_keys(
+    event: &nostr::Event,
+    state: &AppState,
+    keys: &Keys,
+    auth_tag: Option<&str>,
+) -> Result<SubmitEventResponse, String> {
+    if event.pubkey != keys.public_key() {
+        return Err("signed event does not match the publishing identity".to_string());
+    }
+    let url = format!("{}/events", relay_api_base_url_with_override(state));
     let body_bytes = event.as_json().into_bytes();
     let auth_header = build_nip98_auth_header_for_keys(keys, &Method::POST, &url, &body_bytes)?;
 
diff --git a/desktop/src/app/AppShell.tsx b/desktop/src/app/AppShell.tsx
index 5b65584e8c..39c13527a7 100644
--- a/desktop/src/app/AppShell.tsx
+++ b/desktop/src/app/AppShell.tsx
@@ -14,6 +14,7 @@ import { useChannelBrowserDialog } from "@/app/useChannelBrowserDialog";
 import { useMarkAsReadShortcuts } from "@/app/useMarkAsReadShortcuts";
 import { useSettingsShortcuts } from "@/app/useSettingsShortcuts";
 import { useAppShellDesktopNotifications } from "@/app/useAppShellDesktopNotifications";
+import { useAppShellLifecycleEffects } from "@/app/useAppShellLifecycleEffects";
 import { useThreadActivityFeedItems } from "@/app/useThreadActivityFeedItems";
 import { useTauriWindowDrag } from "@/app/useTauriWindowDrag";
 import { useWebviewZoomShortcuts } from "@/app/useWebviewZoomShortcuts";
@@ -33,7 +34,6 @@ import {
   useHomeFeedNotifications,
   useHomeFeedNotificationState,
 } from "@/features/notifications/hooks";
-import { setDesktopAppBadge } from "@/features/notifications/lib/desktop";
 import { PreventSleepProvider } from "@/features/agents/usePreventSleep";
 import { requestOpenCreateAgent } from "@/features/agents/openCreateAgentEvent";
 import { useAgentsDataRefresh } from "@/features/agents/lib/useAgentsDataRefresh";
@@ -567,68 +567,11 @@ export function AppShell() {
     [openSearchHit],
   );
 
-  // Prevent webview file:/// navigation on file drop outside the composer.
-  // Scoped to file drags only (text drag-and-drop into inputs still works).
-  // Composer's onDrop fires first (React synthetic before window bubble).
-  React.useEffect(() => {
-    function preventNavigation(e: DragEvent) {
-      if (e.dataTransfer?.types.includes("Files")) {
-        e.preventDefault();
-      }
-    }
-    window.addEventListener("dragover", preventNavigation);
-    window.addEventListener("drop", preventNavigation);
-    return () => {
-      window.removeEventListener("dragover", preventNavigation);
-      window.removeEventListener("drop", preventNavigation);
-    };
-  }, []);
-
-  React.useEffect(() => {
-    let isCancelled = false;
-
-    const startPreconnect = () => {
-      if (isCancelled) {
-        return;
-      }
-
-      void relayClient.preconnect().catch((error) => {
-        if (!isCancelled) {
-          console.error("Failed to preconnect to relay", error);
-        }
-      });
-    };
-
-    if ("requestIdleCallback" in window) {
-      const idleId = window.requestIdleCallback(startPreconnect, {
-        timeout: 1_500,
-      });
-      return () => {
-        isCancelled = true;
-        window.cancelIdleCallback(idleId);
-      };
-    }
-
-    const timeoutId = globalThis.setTimeout(startPreconnect, 250);
-    return () => {
-      isCancelled = true;
-      globalThis.clearTimeout(timeoutId);
-    };
-  }, []);
-
-  React.useEffect(() => {
-    const count =
-      unreadChannelNotificationCount + homeBadgeCountExcludingHighPriority;
-    void setDesktopAppBadge(
-      count
-        ? { kind: "count", count }
-        : { kind: unreadChannelIds.size ? "dot" : "none" },
-    );
-  }, [
+  useAppShellLifecycleEffects({
     homeBadgeCountExcludingHighPriority,
     unreadChannelIds,
     unreadChannelNotificationCount,
-  ]);
+  });
 
   // Dispatch `buzz://message` deep links into the router.
   useMessageDeepLinks();
diff --git a/desktop/src/app/useAppShellLifecycleEffects.ts b/desktop/src/app/useAppShellLifecycleEffects.ts
new file mode 100644
index 0000000000..cc0447cc32
--- /dev/null
+++ b/desktop/src/app/useAppShellLifecycleEffects.ts
@@ -0,0 +1,79 @@
+import * as React from "react";
+
+import { setDesktopAppBadge } from "@/features/notifications/lib/desktop";
+import { relayClient } from "@/shared/api/relayClient";
+
+type AppShellLifecycleEffectsOptions = {
+  homeBadgeCountExcludingHighPriority: number;
+  unreadChannelIds: ReadonlySet<string>;
+  unreadChannelNotificationCount: number;
+};
+
+export function useAppShellLifecycleEffects({
+  homeBadgeCountExcludingHighPriority,
+  unreadChannelIds,
+  unreadChannelNotificationCount,
+}: AppShellLifecycleEffectsOptions) {
+  // Prevent webview file:/// navigation on file drop outside the composer.
+  // Scoped to file drags only (text drag-and-drop into inputs still works).
+  // Composer's onDrop fires first (React synthetic before window bubble).
+  React.useEffect(() => {
+    function preventNavigation(e: DragEvent) {
+      if (e.dataTransfer?.types.includes("Files")) {
+        e.preventDefault();
+      }
+    }
+    window.addEventListener("dragover", preventNavigation);
+    window.addEventListener("drop", preventNavigation);
+    return () => {
+      window.removeEventListener("dragover", preventNavigation);
+      window.removeEventListener("drop", preventNavigation);
+    };
+  }, []);
+
+  React.useEffect(() => {
+    let isCancelled = false;
+
+    const startPreconnect = () => {
+      if (isCancelled) {
+        return;
+      }
+
+      void relayClient.preconnect().catch((error) => {
+        if (!isCancelled) {
+          console.error("Failed to preconnect to relay", error);
+        }
+      });
+    };
+
+    if ("requestIdleCallback" in window) {
+      const idleId = window.requestIdleCallback(startPreconnect, {
+        timeout: 1_500,
+      });
+      return () => {
+        isCancelled = true;
+        window.cancelIdleCallback(idleId);
+      };
+    }
+
+    const timeoutId = globalThis.setTimeout(startPreconnect, 250);
+    return () => {
+      isCancelled = true;
+      globalThis.clearTimeout(timeoutId);
+    };
+  }, []);
+
+  React.useEffect(() => {
+    const count =
+      unreadChannelNotificationCount + homeBadgeCountExcludingHighPriority;
+    void setDesktopAppBadge(
+      count
+        ? { kind: "count", count }
+        : { kind: unreadChannelIds.size ? "dot" : "none" },
+    );
+  }, [
+    homeBadgeCountExcludingHighPriority,
+    unreadChannelIds,
+    unreadChannelNotificationCount,
+  ]);
+}
diff --git a/desktop/src/features/projects/hooks.ts b/desktop/src/features/projects/hooks.ts
index bd1598a890..5db9d211e3 100644
--- a/desktop/src/features/projects/hooks.ts
+++ b/desktop/src/features/projects/hooks.ts
@@ -273,7 +273,11 @@ async function fetchProject(projectId: string): Promise<Project | null> {
     limit: 10,
   });
 
-  return isDeletedByA(project, deletionEvents) ? null : project;
+  if (isDeletedByA(project, deletionEvents)) return null;
+  const repoState = await fetchRepoState(project);
+  return repoState?.head
+    ? { ...project, defaultBranch: repoState.head }
+    : project;
 }
 
 function eventToRepoState(event: RelayEvent): RepoState {
@@ -290,7 +294,7 @@ function eventToRepoState(event: RelayEvent): RepoState {
     } else if (name.startsWith("refs/tags/")) {
       tags.push({ name: name.slice("refs/tags/".length), commit: value });
     } else if (name === "HEAD") {
-      head = value.replace(/^ref:\s*/, "");
+      head = value.replace(/^ref:\s*/, "").replace(/^refs\/heads\//, "");
     }
   }
 
diff --git a/desktop/src/features/projects/issueMutations.ts b/desktop/src/features/projects/issueMutations.ts
new file mode 100644
index 0000000000..d112850070
--- /dev/null
+++ b/desktop/src/features/projects/issueMutations.ts
@@ -0,0 +1,58 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { relayClient } from "@/shared/api/relayClient";
+import { signRelayEvent } from "@/shared/api/tauri";
+import { KIND_GIT_ISSUE } from "@/shared/constants/kinds";
+import type { Project } from "./hooks";
+import { buildGitIssueTags } from "./projectIssues.mjs";
+
+type CreateProjectIssueInput = {
+  title: string;
+  body: string;
+};
+
+export async function publishProjectIssue(
+  project: Project,
+  input: CreateProjectIssueInput,
+) {
+  const event = await signRelayEvent({
+    kind: KIND_GIT_ISSUE,
+    content: input.body.trim(),
+    tags: buildGitIssueTags({
+      repoAddress: project.repoAddress,
+      repoOwner: project.owner,
+      title: input.title,
+    }),
+  });
+  await relayClient.publishEvent(
+    event,
+    "Timed out creating issue.",
+    "Failed to create issue.",
+  );
+  return event.id;
+}
+
+export function useCreateProjectIssueMutation(
+  project: Project | null | undefined,
+) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (input: CreateProjectIssueInput) => {
+      if (!project) throw new Error("No project selected.");
+      return publishProjectIssue(project, input);
+    },
+    onSuccess: async () => {
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: ["project", project?.id ?? "none", "issues"],
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ["projects", "issues"],
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ["projects", "activity-summaries"],
+        }),
+      ]);
+    },
+  });
+}
diff --git a/desktop/src/features/projects/lib/projectsViewHelpers.ts b/desktop/src/features/projects/lib/projectsViewHelpers.ts
index 188b7a8781..fefb75b4f8 100644
--- a/desktop/src/features/projects/lib/projectsViewHelpers.ts
+++ b/desktop/src/features/projects/lib/projectsViewHelpers.ts
@@ -6,6 +6,8 @@ import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import { normalizePubkey } from "@/shared/lib/pubkey";
 
 export type ProjectsViewMode = "grid" | "list";
+export type ProjectsRepositoryScope = "all" | "mine" | "local";
+export type ProjectsWorkItemScope = "all" | "mine";
 export type ProjectsFilter =
   | "all"
   | "mine"
@@ -19,6 +21,10 @@ export type ProjectsSort = "updated" | "created" | "name";
 
 const PROJECTS_VIEW_MODE_STORAGE_KEY = "buzz.projects.viewMode";
 const PROJECTS_FILTER_STORAGE_KEY = "buzz.projects.filter";
+const PROJECTS_REPOSITORY_SCOPE_STORAGE_KEY = "buzz.projects.repositoryScope";
+const PROJECTS_PULL_REQUEST_SCOPE_STORAGE_KEY =
+  "buzz.projects.pullRequestScope";
+const PROJECTS_ISSUE_SCOPE_STORAGE_KEY = "buzz.projects.issueScope";
 const PROJECTS_SORT_STORAGE_KEY = "buzz.projects.sort";
 
 export function readStoredViewMode(): ProjectsViewMode | null {
@@ -65,6 +71,66 @@ export function writeStoredFilter(filter: ProjectsFilter) {
   }
 }
 
+export function readStoredRepositoryScope(): ProjectsRepositoryScope {
+  try {
+    const value = globalThis.localStorage?.getItem(
+      PROJECTS_REPOSITORY_SCOPE_STORAGE_KEY,
+    );
+    if (value === "mine" || value === "local") return value;
+    const legacyFilter = globalThis.localStorage?.getItem(
+      PROJECTS_FILTER_STORAGE_KEY,
+    );
+    return legacyFilter === "mine" || legacyFilter === "local"
+      ? legacyFilter
+      : "all";
+  } catch {
+    return "all";
+  }
+}
+
+export function writeStoredRepositoryScope(scope: ProjectsRepositoryScope) {
+  try {
+    globalThis.localStorage?.setItem(
+      PROJECTS_REPOSITORY_SCOPE_STORAGE_KEY,
+      scope,
+    );
+  } catch {
+    // Persistence is best-effort; the in-memory filter still works.
+  }
+}
+
+function readStoredWorkItemScope(key: string): ProjectsWorkItemScope {
+  try {
+    return globalThis.localStorage?.getItem(key) === "mine" ? "mine" : "all";
+  } catch {
+    return "all";
+  }
+}
+
+function writeStoredWorkItemScope(key: string, scope: ProjectsWorkItemScope) {
+  try {
+    globalThis.localStorage?.setItem(key, scope);
+  } catch {
+    // Persistence is best-effort; the in-memory filter still works.
+  }
+}
+
+export function readStoredPullRequestScope(): ProjectsWorkItemScope {
+  return readStoredWorkItemScope(PROJECTS_PULL_REQUEST_SCOPE_STORAGE_KEY);
+}
+
+export function writeStoredPullRequestScope(scope: ProjectsWorkItemScope) {
+  writeStoredWorkItemScope(PROJECTS_PULL_REQUEST_SCOPE_STORAGE_KEY, scope);
+}
+
+export function readStoredIssueScope(): ProjectsWorkItemScope {
+  return readStoredWorkItemScope(PROJECTS_ISSUE_SCOPE_STORAGE_KEY);
+}
+
+export function writeStoredIssueScope(scope: ProjectsWorkItemScope) {
+  writeStoredWorkItemScope(PROJECTS_ISSUE_SCOPE_STORAGE_KEY, scope);
+}
+
 export function readStoredSort(): ProjectsSort {
   try {
     const value = globalThis.localStorage?.getItem(PROJECTS_SORT_STORAGE_KEY);
@@ -176,14 +242,14 @@ export function projectPeople(
   ];
 }
 
-function normalizeRepositoryUrl(url: string) {
+export function normalizeRepositoryUrl(url: string) {
   try {
     const parsed = new URL(url);
     const normalizedPath = parsed.pathname
       .replace(/\/+$/, "")
       .replace(/\.git$/i, "")
       .toLowerCase();
-    return `${parsed.hostname.toLowerCase()}${normalizedPath}`;
+    return `${parsed.protocol.toLowerCase()}//${parsed.host.toLowerCase()}${normalizedPath}`;
   } catch {
     return url
       .trim()
diff --git a/desktop/src/features/projects/projectIssues.test.mjs b/desktop/src/features/projects/projectIssues.test.mjs
index b8065675c6..b6fa6a901f 100644
--- a/desktop/src/features/projects/projectIssues.test.mjs
+++ b/desktop/src/features/projects/projectIssues.test.mjs
@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
+  buildGitIssueTags,
   eventToProjectIssue,
   getAllTags,
   getTag,
@@ -97,3 +98,18 @@ test("tag helpers drop malformed value-less tags", () => {
   assert.equal(issue.status, PROJECT_ISSUE_STATUS.BACKLOG);
   assert.equal(issue.title, "Something is broken");
 });
+
+test("builds repository-scoped issue creation tags", () => {
+  assert.deepEqual(
+    buildGitIssueTags({
+      repoAddress: REPO_ADDRESS,
+      repoOwner: OWNER,
+      title: "  Fix the broken workflow  ",
+    }),
+    [
+      ["a", REPO_ADDRESS],
+      ["p", OWNER],
+      ["subject", "Fix the broken workflow"],
+    ],
+  );
+});
diff --git a/desktop/src/features/projects/projectPullRequests.d.mts b/desktop/src/features/projects/projectPullRequests.d.mts
index a426b34ef4..de701bf91d 100644
--- a/desktop/src/features/projects/projectPullRequests.d.mts
+++ b/desktop/src/features/projects/projectPullRequests.d.mts
@@ -45,6 +45,7 @@ export type ProjectPullRequest = {
   statusEventId: string | null;
   statusCreatedAt: number | null;
   branchName: string | null;
+  targetBranch: string | null;
   initialCommit: string | null;
   commit: string | null;
   cloneUrls: string[];
diff --git a/desktop/src/features/projects/projectPullRequests.mjs b/desktop/src/features/projects/projectPullRequests.mjs
index 67beccccb3..721f5db4b3 100644
--- a/desktop/src/features/projects/projectPullRequests.mjs
+++ b/desktop/src/features/projects/projectPullRequests.mjs
@@ -125,12 +125,19 @@ function reviewersForPullRequest(pullRequest, comments) {
   return [...reviewers];
 }
 
-/** Latest approval comment per author, oldest first. */
-function approvalsForPullRequest(comments) {
+/** Latest trusted approval per author, oldest first. */
+function approvalsForPullRequest(pullRequest, comments, reviewers) {
+  const author = pullRequest.pubkey.toLowerCase();
+  const trustedApprovers = new Set(reviewers);
+  for (const actor of allowedActorsForRoot(pullRequest)) {
+    if (actor !== author) trustedApprovers.add(actor);
+  }
+
   const byAuthor = new Map();
   for (const comment of comments) {
     if (!comment.isApproval) continue;
     const key = comment.author.toLowerCase();
+    if (!trustedApprovers.has(key)) continue;
     const existing = byAuthor.get(key);
     if (!existing || comment.createdAt > existing.createdAt) {
       byAuthor.set(key, comment);
@@ -157,7 +164,7 @@ export function eventToProjectPullRequest(
     eventToPullRequestComment,
   );
   const reviewers = reviewersForPullRequest(pullRequest, comments);
-  const approvals = approvalsForPullRequest(comments);
+  const approvals = approvalsForPullRequest(pullRequest, comments, reviewers);
   const title =
     getTag(pullRequest, "subject") ||
     pullRequest.content.split("\n")[0] ||
@@ -180,6 +187,7 @@ export function eventToProjectPullRequest(
     statusEventId: latestStatus?.id ?? null,
     statusCreatedAt: latestStatus?.created_at ?? null,
     branchName: getTag(pullRequest, "branch-name") ?? null,
+    targetBranch: getTag(pullRequest, "target-branch") ?? null,
     initialCommit,
     commit: latestCommit,
     cloneUrls: getCloneUrls(latestUpdate ?? pullRequest),
diff --git a/desktop/src/features/projects/projectPullRequests.test.mjs b/desktop/src/features/projects/projectPullRequests.test.mjs
index 73b347b53b..4379e904d3 100644
--- a/desktop/src/features/projects/projectPullRequests.test.mjs
+++ b/desktop/src/features/projects/projectPullRequests.test.mjs
@@ -22,12 +22,21 @@ function pullRequestEvent(overrides = {}) {
       ["a", REPO_ADDRESS],
       ["subject", "Add feature"],
       ["c", "1111111111111111111111111111111111111111"],
+      ["branch-name", "feature/demo"],
+      ["target-branch", "release"],
       ["clone", `https://relay.example/git/${OWNER}/demo`],
     ],
     ...overrides,
   };
 }
 
+test("reads source and target branches from the pull request", () => {
+  const pullRequest = eventToProjectPullRequest(pullRequestEvent());
+
+  assert.equal(pullRequest.branchName, "feature/demo");
+  assert.equal(pullRequest.targetBranch, "release");
+});
+
 function updateEvent({ pubkey, createdAt, commit, cloneUrl }) {
   return {
     id: `update-${pubkey.slice(0, 8)}-${createdAt}`,
@@ -247,6 +256,8 @@ test("reviewers come from root p tags plus trusted review requests", () => {
 
 test("approvals keep the latest per author and flag comments", () => {
   const reviewer = "d".repeat(64);
+  const event = pullRequestEvent();
+  event.tags.push(["p", reviewer]);
   const firstApproval = commentEvent({
     pubkey: reviewer,
     createdAt: 200,
@@ -266,7 +277,7 @@ test("approvals keep the latest per author and flag comments", () => {
   });
 
   const pullRequest = eventToProjectPullRequest(
-    pullRequestEvent(),
+    event,
     [],
     [firstApproval, plainComment, secondApproval],
   );
@@ -284,6 +295,41 @@ test("approvals keep the latest per author and flag comments", () => {
   );
 });
 
+test("approvals only count requested reviewers and the repository owner", () => {
+  const reviewer = "d".repeat(64);
+  const event = pullRequestEvent();
+  event.tags.push(["p", reviewer]);
+  const comments = [
+    commentEvent({
+      pubkey: reviewer,
+      createdAt: 200,
+      labels: ["approval"],
+    }),
+    commentEvent({
+      pubkey: OWNER,
+      createdAt: 210,
+      labels: ["approval"],
+    }),
+    commentEvent({
+      pubkey: ATTACKER,
+      createdAt: 220,
+      labels: ["approval"],
+    }),
+    commentEvent({
+      pubkey: AUTHOR,
+      createdAt: 230,
+      labels: ["approval"],
+    }),
+  ];
+
+  const pullRequest = eventToProjectPullRequest(event, [], comments);
+
+  assert.deepEqual(
+    pullRequest.approvals.map((approval) => approval.author),
+    [reviewer, OWNER],
+  );
+});
+
 test("survives malformed value-less tags", () => {
   const event = pullRequestEvent({
     tags: [
diff --git a/desktop/src/features/projects/pullRequestMutations.test.mjs b/desktop/src/features/projects/pullRequestMutations.test.mjs
new file mode 100644
index 0000000000..989eb87975
--- /dev/null
+++ b/desktop/src/features/projects/pullRequestMutations.test.mjs
@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  canPublishProjectPullRequestUpdate,
+  projectPullRequestMergedTags,
+  projectPullRequestTags,
+  projectPullRequestUpdateTags,
+} from "./pullRequestMutations.ts";
+
+const OWNER = "a".repeat(64);
+const AUTHOR = "b".repeat(64);
+const REVIEWER = "c".repeat(64);
+const PR_ID = "d".repeat(64);
+const COMMIT = "e".repeat(40);
+const MERGE_BASE = "f".repeat(40);
+
+const project = {
+  owner: OWNER,
+  repoAddress: `30617:${OWNER}:buzz`,
+  cloneUrls: [`https://relay.example/git/${OWNER}/buzz`],
+};
+const pullRequest = {
+  author: AUTHOR,
+};
+
+test("only the repository owner or PR author can publish an update", () => {
+  assert.equal(
+    canPublishProjectPullRequestUpdate(OWNER, project, pullRequest),
+    true,
+  );
+  assert.equal(
+    canPublishProjectPullRequestUpdate(AUTHOR, project, pullRequest),
+    true,
+  );
+  assert.equal(
+    canPublishProjectPullRequestUpdate(REVIEWER, project, pullRequest),
+    false,
+  );
+});
+
+test("projectPullRequestTags builds a NIP-34 kind 1618 tag set", () => {
+  const tags = projectPullRequestTags(project, {
+    title: "Add Projects workflow",
+    body: "",
+    branch: "projects-workflow",
+    targetBranch: "main",
+    commit: COMMIT,
+    mergeBase: MERGE_BASE,
+    reviewers: [REVIEWER, REVIEWER.toUpperCase()],
+  });
+
+  assert.deepEqual(tags, [
+    ["a", project.repoAddress],
+    ["p", OWNER],
+    ["p", REVIEWER],
+    ["subject", "Add Projects workflow"],
+    ["c", COMMIT],
+    ["clone", project.cloneUrls[0]],
+    ["branch-name", "projects-workflow"],
+    ["target-branch", "main"],
+    ["merge-base", MERGE_BASE],
+  ]);
+});
+
+test("projectPullRequestUpdateTags uses uppercase NIP-22 root tags", () => {
+  const forkCloneUrl = `https://relay.example/git/${AUTHOR}/buzz`;
+  const tags = projectPullRequestUpdateTags(
+    project,
+    { id: PR_ID, author: AUTHOR, cloneUrls: [forkCloneUrl] },
+    COMMIT,
+    MERGE_BASE,
+  );
+
+  assert.ok(tags.some((tag) => tag[0] === "E" && tag[1] === PR_ID));
+  assert.ok(tags.some((tag) => tag[0] === "P" && tag[1] === AUTHOR));
+  assert.ok(tags.some((tag) => tag[0] === "c" && tag[1] === COMMIT));
+  assert.ok(
+    tags.some(
+      (tag) =>
+        tag[0] === "clone" &&
+        tag[1] === forkCloneUrl &&
+        !tag.includes(project.cloneUrls[0]),
+    ),
+  );
+});
+
+test("projectPullRequestMergedTags records the pushed merge commit", () => {
+  const tags = projectPullRequestMergedTags(
+    project,
+    { id: PR_ID, author: AUTHOR },
+    COMMIT,
+  );
+
+  assert.deepEqual(tags, [
+    ["e", PR_ID, "", "root"],
+    ["a", project.repoAddress],
+    ["p", OWNER],
+    ["p", AUTHOR],
+    ["merge-commit", COMMIT],
+    ["r", COMMIT],
+  ]);
+});
diff --git a/desktop/src/features/projects/pullRequestMutations.ts b/desktop/src/features/projects/pullRequestMutations.ts
new file mode 100644
index 0000000000..4eae6464bf
--- /dev/null
+++ b/desktop/src/features/projects/pullRequestMutations.ts
@@ -0,0 +1,271 @@
+import { useMutation } from "@tanstack/react-query";
+
+import {
+  mergeProjectPullRequest,
+  publishProjectPullRequestMergedStatus,
+} from "@/shared/api/projectGit";
+import { relayClient } from "@/shared/api/relayClient";
+import { signRelayEvent } from "@/shared/api/tauri";
+import { getIdentity } from "@/shared/api/tauriIdentity";
+import {
+  KIND_GIT_PR_UPDATE,
+  KIND_GIT_PULL_REQUEST,
+} from "@/shared/constants/kinds";
+import { normalizePubkey } from "@/shared/lib/pubkey";
+import type { Project, ProjectPullRequest } from "./hooks";
+import { nextProjectPullRequestStatusCreatedAt } from "./projectPullRequests.mjs";
+import { useProjectPullRequestWriteInvalidation } from "./pullRequestReviews";
+
+type CreateProjectPullRequestInput = {
+  title: string;
+  body: string;
+  branch: string;
+  targetBranch: string;
+  commit: string;
+  mergeBase: string | null;
+  reviewers: string[];
+};
+
+function uniquePubkeys(pubkeys: readonly string[]) {
+  return [...new Set(pubkeys.map(normalizePubkey))];
+}
+
+export function projectPullRequestTags(
+  project: Project,
+  input: CreateProjectPullRequestInput,
+): string[][] {
+  const tags = [
+    ["a", project.repoAddress],
+    ...uniquePubkeys([project.owner, ...input.reviewers]).map((pubkey) => [
+      "p",
+      pubkey,
+    ]),
+    ["subject", input.title],
+    ["c", input.commit],
+    ["clone", ...project.cloneUrls],
+    ["branch-name", input.branch],
+    ["target-branch", input.targetBranch],
+  ];
+  if (input.mergeBase) tags.push(["merge-base", input.mergeBase]);
+  return tags;
+}
+
+export function projectPullRequestUpdateTags(
+  project: Project,
+  pullRequest: ProjectPullRequest,
+  commit: string,
+  mergeBase: string | null,
+): string[][] {
+  const tags = [
+    ["a", project.repoAddress],
+    ...uniquePubkeys([project.owner, pullRequest.author]).map((pubkey) => [
+      "p",
+      pubkey,
+    ]),
+    ["E", pullRequest.id],
+    ["P", normalizePubkey(pullRequest.author)],
+    ["c", commit],
+    [
+      "clone",
+      ...(pullRequest.cloneUrls.length > 0
+        ? pullRequest.cloneUrls
+        : project.cloneUrls),
+    ],
+  ];
+  if (mergeBase) tags.push(["merge-base", mergeBase]);
+  return tags;
+}
+
+export function projectPullRequestMergedTags(
+  project: Project,
+  pullRequest: ProjectPullRequest,
+  mergeCommit: string,
+): string[][] {
+  return [
+    ["e", pullRequest.id, "", "root"],
+    ["a", project.repoAddress],
+    ...uniquePubkeys([project.owner, pullRequest.author]).map((pubkey) => [
+      "p",
+      pubkey,
+    ]),
+    ["merge-commit", mergeCommit],
+    ["r", mergeCommit],
+  ];
+}
+
+/** Whether the active identity may publish a trusted update for this PR. */
+export function canPublishProjectPullRequestUpdate(
+  viewerPubkey: string,
+  project: Project,
+  pullRequest: ProjectPullRequest,
+) {
+  const viewer = normalizePubkey(viewerPubkey);
+  return (
+    viewer === normalizePubkey(project.owner) ||
+    viewer === normalizePubkey(pullRequest.author)
+  );
+}
+
+async function publishProjectPullRequest(
+  project: Project,
+  input: CreateProjectPullRequestInput,
+) {
+  const title = input.title.trim();
+  if (!title) throw new Error("Pull request title cannot be empty.");
+  if (title.length > 256) {
+    throw new Error("Pull request title must be 256 characters or fewer.");
+  }
+  if (project.cloneUrls.length === 0) {
+    throw new Error("This project has no clone URL.");
+  }
+  if (input.branch === input.targetBranch) {
+    throw new Error("The base and compare branches must be different.");
+  }
+
+  const event = await signRelayEvent({
+    kind: KIND_GIT_PULL_REQUEST,
+    content: input.body.trim(),
+    tags: projectPullRequestTags(project, { ...input, title }),
+  });
+  await relayClient.publishEvent(
+    event,
+    "Timed out creating pull request.",
+    "Failed to create pull request.",
+  );
+  return event.id;
+}
+
+export async function publishProjectPullRequestUpdate({
+  commit,
+  mergeBase,
+  project,
+  pullRequest,
+}: {
+  commit: string;
+  mergeBase: string | null;
+  project: Project;
+  pullRequest: ProjectPullRequest;
+}): Promise<boolean> {
+  if (pullRequest.commit?.toLowerCase() === commit.toLowerCase()) return false;
+  const identity = await getIdentity();
+  if (
+    !canPublishProjectPullRequestUpdate(identity.pubkey, project, pullRequest)
+  ) {
+    throw new Error(
+      "Only the pull request author or repository owner can publish its update.",
+    );
+  }
+  const event = await signRelayEvent({
+    kind: KIND_GIT_PR_UPDATE,
+    content: "",
+    createdAt: Math.max(
+      Math.floor(Date.now() / 1_000),
+      ...pullRequest.updates.map((update) => update.createdAt + 1),
+    ),
+    tags: projectPullRequestUpdateTags(project, pullRequest, commit, mergeBase),
+  });
+  await relayClient.publishEvent(
+    event,
+    "Timed out updating pull request.",
+    "The branch was pushed, but the pull request update could not be published.",
+  );
+  return true;
+}
+
+export async function publishProjectPullRequestMerged(
+  project: Project,
+  statusEvent: string,
+) {
+  await publishProjectPullRequestMergedStatus({
+    targetOwner: project.owner,
+    statusEvent,
+  });
+}
+
+export function useCreateProjectPullRequestMutation(
+  project: Project | null | undefined,
+) {
+  const invalidate = useProjectPullRequestWriteInvalidation(project);
+  return useMutation({
+    mutationFn: (input: CreateProjectPullRequestInput) => {
+      if (!project) throw new Error("No project selected.");
+      return publishProjectPullRequest(project, input);
+    },
+    onSuccess: invalidate,
+  });
+}
+
+export function useUpdateProjectPullRequestMutation(
+  project: Project | null | undefined,
+  pullRequest: ProjectPullRequest | null,
+) {
+  const invalidate = useProjectPullRequestWriteInvalidation(project);
+  return useMutation({
+    mutationFn: async ({
+      commit,
+      mergeBase,
+    }: {
+      commit: string;
+      mergeBase: string | null;
+    }) => {
+      if (!project) throw new Error("No project selected.");
+      if (!pullRequest)
+        throw new Error("No open pull request for this branch.");
+      return publishProjectPullRequestUpdate({
+        commit,
+        mergeBase,
+        project,
+        pullRequest,
+      });
+    },
+    onSuccess: invalidate,
+  });
+}
+
+export function useMergeProjectPullRequestMutation(
+  project: Project | null | undefined,
+) {
+  const invalidate = useProjectPullRequestWriteInvalidation(project);
+  return useMutation({
+    mutationFn: async ({
+      pullRequest,
+    }: {
+      pullRequest: ProjectPullRequest;
+    }) => {
+      if (!project?.cloneUrls[0]) throw new Error("No project selected.");
+      if (!pullRequest.branchName || !pullRequest.commit) {
+        throw new Error("Pull request branch information is incomplete.");
+      }
+      const result = await mergeProjectPullRequest({
+        targetCloneUrl: project.cloneUrls[0],
+        sourceCloneUrl: pullRequest.cloneUrls[0] ?? project.cloneUrls[0],
+        targetOwner: project.owner,
+        repoAddress: project.repoAddress,
+        pullRequestId: pullRequest.id,
+        pullRequestAuthor: pullRequest.author,
+        statusCreatedAt: nextProjectPullRequestStatusCreatedAt(
+          pullRequest,
+          Math.floor(Date.now() / 1_000),
+        ),
+        targetBranch: pullRequest.targetBranch ?? project.defaultBranch,
+        sourceBranch: pullRequest.branchName,
+        expectedCommit: pullRequest.commit,
+      });
+      return result;
+    },
+    onSuccess: invalidate,
+  });
+}
+
+export function usePublishProjectPullRequestMergedMutation(
+  project: Project | null | undefined,
+) {
+  const invalidate = useProjectPullRequestWriteInvalidation(project);
+  return useMutation({
+    mutationFn: ({ statusEvent }: { statusEvent: string }) => {
+      if (!project) throw new Error("No project selected.");
+      return publishProjectPullRequestMerged(project, statusEvent);
+    },
+    onSuccess: invalidate,
+  });
+}
diff --git a/desktop/src/features/projects/pullRequestReviews.ts b/desktop/src/features/projects/pullRequestReviews.ts
index e4eec54116..7606dbefa4 100644
--- a/desktop/src/features/projects/pullRequestReviews.ts
+++ b/desktop/src/features/projects/pullRequestReviews.ts
@@ -1,6 +1,7 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
 import * as React from "react";
 
+import { signProjectPullRequestReviewRequest } from "@/shared/api/projectGit";
 import { relayClient } from "@/shared/api/relayClient";
 import { signRelayEvent } from "@/shared/api/tauri";
 import {
@@ -79,11 +80,13 @@ async function requestProjectPullRequestReview({
   pullRequest,
   reviewers,
   reviewerLabel,
+  signAsManagedOwner,
 }: {
   project: Project;
   pullRequest: ProjectPullRequest;
   reviewers: string[];
   reviewerLabel: string;
+  signAsManagedOwner: boolean;
 }): Promise<void> {
   if (reviewers.length === 0) {
     throw new Error("Select at least one reviewer.");
@@ -91,6 +94,16 @@ async function requestProjectPullRequestReview({
   const reviewerPubkeys = [
     ...new Set(reviewers.map((pubkey) => pubkey.toLowerCase())),
   ];
+  if (signAsManagedOwner) {
+    await signProjectPullRequestReviewRequest({
+      targetOwner: project.owner,
+      repoAddress: project.repoAddress,
+      pullRequestId: pullRequest.id,
+      reviewers: reviewerPubkeys,
+      reviewerLabel,
+    });
+    return;
+  }
   const event = await signRelayEvent({
     kind: KIND_TEXT_NOTE,
     content: `Requested a review from ${reviewerLabel}`,
@@ -138,7 +151,9 @@ async function approveProjectPullRequest({
   );
 }
 
-function usePullRequestWriteInvalidation(project: Project | null | undefined) {
+export function useProjectPullRequestWriteInvalidation(
+  project: Project | null | undefined,
+) {
   const queryClient = useQueryClient();
   return React.useCallback(() => {
     void queryClient.invalidateQueries({
@@ -156,7 +171,7 @@ function usePullRequestWriteInvalidation(project: Project | null | undefined) {
 export function useUpdateProjectPullRequestStatusMutation(
   project: Project | null | undefined,
 ) {
-  const invalidate = usePullRequestWriteInvalidation(project);
+  const invalidate = useProjectPullRequestWriteInvalidation(project);
 
   return useMutation({
     mutationFn: ({
@@ -176,17 +191,19 @@ export function useUpdateProjectPullRequestStatusMutation(
 export function useRequestProjectPullRequestReviewMutation(
   project: Project | null | undefined,
 ) {
-  const invalidate = usePullRequestWriteInvalidation(project);
+  const invalidate = useProjectPullRequestWriteInvalidation(project);
 
   return useMutation({
     mutationFn: ({
       pullRequest,
       reviewers,
       reviewerLabel,
+      signAsManagedOwner,
     }: {
       pullRequest: ProjectPullRequest;
       reviewers: string[];
       reviewerLabel: string;
+      signAsManagedOwner: boolean;
     }) => {
       if (!project) throw new Error("No project selected.");
       return requestProjectPullRequestReview({
@@ -194,6 +211,7 @@ export function useRequestProjectPullRequestReviewMutation(
         pullRequest,
         reviewers,
         reviewerLabel,
+        signAsManagedOwner,
       });
     },
     onSuccess: invalidate,
@@ -203,7 +221,7 @@ export function useRequestProjectPullRequestReviewMutation(
 export function useApproveProjectPullRequestMutation(
   project: Project | null | undefined,
 ) {
-  const invalidate = usePullRequestWriteInvalidation(project);
+  const invalidate = useProjectPullRequestWriteInvalidation(project);
 
   return useMutation({
     mutationFn: ({ pullRequest }: { pullRequest: ProjectPullRequest }) => {
diff --git a/desktop/src/features/projects/repoSyncHooks.ts b/desktop/src/features/projects/repoSyncHooks.ts
index 6cfe6d9be5..457ccca175 100644
--- a/desktop/src/features/projects/repoSyncHooks.ts
+++ b/desktop/src/features/projects/repoSyncHooks.ts
@@ -1,11 +1,13 @@
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 import {
+  cloneProjectRepository,
   getProjectRepoSyncStatus,
   pullProjectLocalRepository,
   pushProjectLocalRepository,
 } from "@/shared/api/projectGit";
-import type { Project } from "@/features/projects/hooks";
+import type { Project, ProjectPullRequest } from "@/features/projects/hooks";
+import { publishProjectPullRequestUpdate } from "./pullRequestMutations";
 
 /** Local-vs-remote git sync status for a project checkout (ahead/behind
  * counts, push/pull availability). Polls gently — each check runs a
@@ -15,8 +17,10 @@ export function useProjectRepoSyncStatusQuery(
   project: Project | null | undefined,
   reposDir?: string | null,
   branchName?: string | null,
+  baseBranch?: string | null,
 ) {
   const selectedBranch = branchName ?? project?.defaultBranch ?? null;
+  const selectedBaseBranch = baseBranch ?? project?.defaultBranch ?? null;
 
   return useQuery({
     enabled: Boolean(project?.cloneUrls[0]),
@@ -26,6 +30,7 @@ export function useProjectRepoSyncStatusQuery(
       "repo-sync-status",
       reposDir ?? "default",
       selectedBranch ?? "default",
+      selectedBaseBranch ?? "default",
     ],
     queryFn: () => {
       if (!project?.cloneUrls[0]) throw new Error("No project selected.");
@@ -33,7 +38,8 @@ export function useProjectRepoSyncStatusQuery(
         reposDir,
         projectDtag: project.dtag,
         cloneUrl: project.cloneUrls[0],
-        defaultBranch: selectedBranch,
+        branchName: selectedBranch,
+        baseBranch: selectedBaseBranch,
       });
     },
     staleTime: 10_000,
@@ -48,19 +54,49 @@ export function usePushProjectLocalRepositoryMutation(
   project: Project | null | undefined,
   reposDir?: string | null,
   branchName?: string | null,
+  pullRequest?: ProjectPullRequest | null,
 ) {
   const queryClient = useQueryClient();
   const selectedBranch = branchName ?? project?.defaultBranch ?? null;
 
   return useMutation({
-    mutationFn: () => {
+    mutationFn: async () => {
       if (!project?.cloneUrls[0]) throw new Error("No project selected.");
-      return pushProjectLocalRepository({
+      const result = await pushProjectLocalRepository({
         reposDir,
         projectDtag: project.dtag,
         cloneUrl: project.cloneUrls[0],
-        defaultBranch: selectedBranch,
+        branchName: selectedBranch,
+        baseBranch: project.defaultBranch,
       });
+      let pullRequestUpdate:
+        | { status: "skipped" | "unchanged" | "updated" }
+        | { status: "failed"; error: string } = { status: "skipped" };
+      if (
+        pullRequest &&
+        (pullRequest.status === "Open" || pullRequest.status === "Draft")
+      ) {
+        try {
+          const updated = await publishProjectPullRequestUpdate({
+            commit: result.commit,
+            mergeBase: result.mergeBase,
+            project,
+            pullRequest,
+          });
+          pullRequestUpdate = {
+            status: updated ? "updated" : "unchanged",
+          };
+        } catch (error) {
+          pullRequestUpdate = {
+            status: "failed",
+            error:
+              error instanceof Error
+                ? error.message
+                : "The pull request update could not be published.",
+          };
+        }
+      }
+      return { ...result, pullRequestUpdate };
     },
     onSuccess: () => {
       void queryClient.invalidateQueries({
@@ -71,6 +107,38 @@ export function usePushProjectLocalRepositoryMutation(
   });
 }
 
+/** Clones a project into the workspace repositories directory. */
+export function useCloneProjectRepositoryMutation(
+  project: Project | null | undefined,
+  reposDir?: string | null,
+) {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: () => {
+      if (!project?.cloneUrls[0]) throw new Error("No project selected.");
+      return cloneProjectRepository({
+        reposDir,
+        projectDtag: project.dtag,
+        cloneUrl: project.cloneUrls[0],
+        defaultBranch: project.defaultBranch,
+      });
+    },
+    onSuccess: async () => {
+      await Promise.all([
+        queryClient.invalidateQueries({
+          queryKey: ["project", project?.id ?? "none", "local-repo-snapshot"],
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ["project", project?.id ?? "none", "repo-sync-status"],
+        }),
+        queryClient.invalidateQueries({
+          queryKey: ["projects", "local-repositories"],
+        }),
+      ]);
+    },
+  });
+}
+
 /** Fast-forwards the local checkout to the remote branch head. */
 export function usePullProjectLocalRepositoryMutation(
   project: Project | null | undefined,
@@ -87,7 +155,7 @@ export function usePullProjectLocalRepositoryMutation(
         reposDir,
         projectDtag: project.dtag,
         cloneUrl: project.cloneUrls[0],
-        defaultBranch: selectedBranch,
+        branchName: selectedBranch,
       });
     },
     onSuccess: () => {
diff --git a/desktop/src/features/projects/ui/CreateIssueDialog.tsx b/desktop/src/features/projects/ui/CreateIssueDialog.tsx
new file mode 100644
index 0000000000..6a3d679f57
--- /dev/null
+++ b/desktop/src/features/projects/ui/CreateIssueDialog.tsx
@@ -0,0 +1,34 @@
+import {
+  CreateProjectWorkItemDialog,
+  type CreateProjectWorkItemDialogInput,
+} from "./CreateProjectWorkItemDialog";
+
+export type CreateIssueDialogInput = CreateProjectWorkItemDialogInput;
+
+export function CreateIssueDialog({
+  isCreating,
+  onCreate,
+  onOpenChange,
+  open,
+  projectName,
+}: {
+  isCreating: boolean;
+  onCreate: (input: CreateIssueDialogInput) => Promise<void>;
+  onOpenChange: (open: boolean) => void;
+  open: boolean;
+  projectName: string;
+}) {
+  return (
+    <CreateProjectWorkItemDialog
+      bodyPlaceholder="Add context, expected behavior, or reproduction steps"
+      description={`Create an issue in ${projectName}`}
+      isCreating={isCreating}
+      itemName="issue"
+      onCreate={onCreate}
+      onOpenChange={onOpenChange}
+      open={open}
+      title="Create an issue"
+      titlePlaceholder="Describe the issue"
+    />
+  );
+}
diff --git a/desktop/src/features/projects/ui/CreateProjectIssueDialog.tsx b/desktop/src/features/projects/ui/CreateProjectIssueDialog.tsx
new file mode 100644
index 0000000000..af28693bb4
--- /dev/null
+++ b/desktop/src/features/projects/ui/CreateProjectIssueDialog.tsx
@@ -0,0 +1,81 @@
+import * as React from "react";
+import { toast } from "sonner";
+
+import type { Project } from "@/features/projects/hooks";
+import { useCreateProjectIssueMutation } from "@/features/projects/issueMutations";
+import {
+  CreateProjectWorkItemDialog,
+  type CreateProjectWorkItemDialogInput,
+} from "./CreateProjectWorkItemDialog";
+
+export function CreateProjectIssueDialog({
+  initialProjectId,
+  onCreated,
+  onOpenChange,
+  open,
+  projects,
+}: {
+  initialProjectId?: string;
+  onCreated: (project: Project, issueId: string) => void | Promise<void>;
+  onOpenChange: (open: boolean) => void;
+  open: boolean;
+  projects: Project[];
+}) {
+  const initialProject =
+    projects.find((project) => project.id === initialProjectId) ?? projects[0];
+  const [projectId, setProjectId] = React.useState(initialProject?.id ?? "");
+  const project =
+    projects.find((candidate) => candidate.id === projectId) ?? initialProject;
+  const createMutation = useCreateProjectIssueMutation(project);
+
+  React.useEffect(() => {
+    if (!open) return;
+    const nextProject =
+      projects.find((candidate) => candidate.id === initialProjectId) ??
+      projects[0];
+    setProjectId(nextProject?.id ?? "");
+  }, [initialProjectId, open, projects]);
+
+  async function handleCreate(input: CreateProjectWorkItemDialogInput) {
+    if (!project) throw new Error("Choose a repository.");
+    const issueId = await createMutation.mutateAsync(input);
+    toast.success("Issue created.");
+    await onCreated(project, issueId);
+  }
+
+  return (
+    <CreateProjectWorkItemDialog
+      bodyPlaceholder="Add context, expected behavior, or reproduction steps"
+      description={
+        project
+          ? `Create an issue in ${project.name}`
+          : "Choose a repository for this issue."
+      }
+      isCreating={createMutation.isPending}
+      itemName="issue"
+      onCreate={handleCreate}
+      onOpenChange={onOpenChange}
+      open={open}
+      submitDisabled={!project}
+      title="Create an issue"
+      titlePlaceholder="Describe the issue"
+    >
+      <label className="block space-y-1.5 text-sm font-medium">
+        <span>Repository</span>
+        <select
+          className="h-10 w-full rounded-lg border border-input bg-background px-3 text-sm font-normal outline-hidden focus:ring-1 focus:ring-ring"
+          data-testid="create-issue-repository"
+          disabled={createMutation.isPending}
+          onChange={(event) => setProjectId(event.target.value)}
+          value={project?.id ?? ""}
+        >
+          {projects.map((candidate) => (
+            <option key={candidate.id} value={candidate.id}>
+              {candidate.name}
+            </option>
+          ))}
+        </select>
+      </label>
+    </CreateProjectWorkItemDialog>
+  );
+}
diff --git a/desktop/src/features/projects/ui/CreateProjectWorkItemDialog.tsx b/desktop/src/features/projects/ui/CreateProjectWorkItemDialog.tsx
new file mode 100644
index 0000000000..73819c9617
--- /dev/null
+++ b/desktop/src/features/projects/ui/CreateProjectWorkItemDialog.tsx
@@ -0,0 +1,189 @@
+import * as React from "react";
+
+import { cn } from "@/shared/lib/cn";
+import { Button } from "@/shared/ui/button";
+import { ChooserDialogContent } from "@/shared/ui/chooser-dialog-content";
+import { Dialog } from "@/shared/ui/dialog";
+import { Input } from "@/shared/ui/input";
+import { Textarea } from "@/shared/ui/textarea";
+
+const FIELD_SHELL_CLASS =
+  "rounded-xl border border-input bg-muted/40 transition-colors hover:border-muted-foreground/40 focus-within:border-muted-foreground/50";
+const FIELD_CONTROL_CLASS =
+  "border-0 bg-transparent shadow-none outline-none ring-0 placeholder:text-muted-foreground/55 focus-visible:ring-0";
+
+export type CreateProjectWorkItemDialogInput = {
+  title: string;
+  body: string;
+};
+
+export function CreateProjectWorkItemDialog({
+  bodyPlaceholder,
+  children,
+  description,
+  isCreating,
+  itemName,
+  onCreate,
+  onOpenChange,
+  open,
+  submitDisabled = false,
+  title,
+  titlePlaceholder,
+}: {
+  bodyPlaceholder: string;
+  children?: React.ReactNode;
+  description: string;
+  isCreating: boolean;
+  itemName: "issue" | "pull-request";
+  onCreate: (input: CreateProjectWorkItemDialogInput) => Promise<void>;
+  onOpenChange: (open: boolean) => void;
+  open: boolean;
+  submitDisabled?: boolean;
+  title: string;
+  titlePlaceholder: string;
+}) {
+  const [workItemTitle, setWorkItemTitle] = React.useState("");
+  const [body, setBody] = React.useState("");
+  const [errorMessage, setErrorMessage] = React.useState<string | null>(null);
+  const titleInputRef = React.useRef<HTMLInputElement>(null);
+  const submitInFlightRef = React.useRef(false);
+  const testIdPrefix = `create-${itemName}`;
+  const itemLabel = itemName === "issue" ? "issue" : "pull request";
+
+  React.useEffect(() => {
+    if (!open) return;
+    setWorkItemTitle("");
+    setBody("");
+    setErrorMessage(null);
+    const timerId = globalThis.setTimeout(
+      () => titleInputRef.current?.focus(),
+      50,
+    );
+    return () => globalThis.clearTimeout(timerId);
+  }, [open]);
+
+  async function handleSubmit(event: React.FormEvent<HTMLFormElement>) {
+    event.preventDefault();
+    if (isCreating || submitDisabled || submitInFlightRef.current) return;
+    const trimmedTitle = workItemTitle.trim();
+    if (!trimmedTitle) return;
+    submitInFlightRef.current = true;
+    setErrorMessage(null);
+    try {
+      await onCreate({ title: trimmedTitle, body: body.trim() });
+      onOpenChange(false);
+    } catch (error) {
+      setErrorMessage(
+        error instanceof Error
+          ? error.message
+          : `Failed to create ${itemLabel}.`,
+      );
+    } finally {
+      submitInFlightRef.current = false;
+    }
+  }
+
+  return (
+    <Dialog
+      onOpenChange={(nextOpen) => {
+        if (!nextOpen && isCreating) return;
+        onOpenChange(nextOpen);
+      }}
+      open={open}
+    >
+      <ChooserDialogContent
+        className="max-w-lg"
+        contentClassName="pt-3"
+        data-testid={`${testIdPrefix}-dialog`}
+        description={description}
+        footer={
+          <div className="flex w-full justify-end">
+            <Button
+              data-testid={`${testIdPrefix}-submit`}
+              disabled={
+                isCreating ||
+                submitDisabled ||
+                workItemTitle.trim().length === 0
+              }
+              form={`${testIdPrefix}-form`}
+              type="submit"
+            >
+              {isCreating ? "Creating…" : `Create ${itemLabel}`}
+            </Button>
+          </div>
+        }
+        footerClassName="border-t-0 pt-0"
+        headerClassName="pb-2"
+        title={title}
+      >
+        <form
+          className="space-y-5"
+          id={`${testIdPrefix}-form`}
+          onSubmit={(event) => void handleSubmit(event)}
+        >
+          {children}
+          <div className="space-y-1.5">
+            <label
+              className="text-sm font-medium text-foreground"
+              htmlFor={`${testIdPrefix}-title`}
+            >
+              Title
+            </label>
+            <div
+              className={cn(
+                "flex min-h-11 items-center px-3",
+                FIELD_SHELL_CLASS,
+              )}
+            >
+              <Input
+                className={cn("h-8 px-0", FIELD_CONTROL_CLASS)}
+                data-testid={`${testIdPrefix}-title`}
+                disabled={isCreating}
+                id={`${testIdPrefix}-title`}
+                maxLength={256}
+                onChange={(event) => {
+                  setWorkItemTitle(event.target.value);
+                  setErrorMessage(null);
+                }}
+                placeholder={titlePlaceholder}
+                ref={titleInputRef}
+                value={workItemTitle}
+              />
+            </div>
+          </div>
+          <div className="space-y-1.5">
+            <label
+              className="text-sm font-medium text-foreground"
+              htmlFor={`${testIdPrefix}-body`}
+            >
+              Description
+              <span className="ml-1 text-xs font-normal text-muted-foreground/50">
+                Optional
+              </span>
+            </label>
+            <div className={FIELD_SHELL_CLASS}>
+              <Textarea
+                className={cn(
+                  "min-h-28 resize-y px-3 py-3",
+                  FIELD_CONTROL_CLASS,
+                )}
+                data-testid={`${testIdPrefix}-body`}
+                disabled={isCreating}
+                id={`${testIdPrefix}-body`}
+                onChange={(event) => {
+                  setBody(event.target.value);
+                  setErrorMessage(null);
+                }}
+                placeholder={bodyPlaceholder}
+                value={body}
+              />
+            </div>
+          </div>
+          {errorMessage ? (
+            <p className="text-sm text-destructive">{errorMessage}</p>
+          ) : null}
+        </form>
+      </ChooserDialogContent>
+    </Dialog>
+  );
+}
diff --git a/desktop/src/features/projects/ui/CreatePullRequestDialog.tsx b/desktop/src/features/projects/ui/CreatePullRequestDialog.tsx
new file mode 100644
index 0000000000..d64d132aed
--- /dev/null
+++ b/desktop/src/features/projects/ui/CreatePullRequestDialog.tsx
@@ -0,0 +1,221 @@
+import * as React from "react";
+import { toast } from "sonner";
+
+import {
+  type Project,
+  useProjectPullRequestsQuery,
+  useRepoStateQuery,
+} from "@/features/projects/hooks";
+import { useCreateProjectPullRequestMutation } from "@/features/projects/pullRequestMutations";
+import { useProjectRepoSyncStatusQuery } from "@/features/projects/repoSyncHooks";
+
+import {
+  CreateProjectWorkItemDialog,
+  type CreateProjectWorkItemDialogInput,
+} from "./CreateProjectWorkItemDialog";
+
+export type CreatePullRequestDialogInput = CreateProjectWorkItemDialogInput;
+
+export function CreatePullRequestDialog({
+  initialProjectId,
+  onCreated,
+  onOpenChange,
+  open,
+  projects,
+  reposDir,
+}: {
+  initialProjectId?: string;
+  onCreated: (project: Project, pullRequestId: string) => void | Promise<void>;
+  onOpenChange: (open: boolean) => void;
+  open: boolean;
+  projects: Project[];
+  reposDir?: string | null;
+}) {
+  const initialProject =
+    projects.find((project) => project.id === initialProjectId) ?? projects[0];
+  const [projectId, setProjectId] = React.useState(initialProject?.id ?? "");
+  const project =
+    projects.find((candidate) => candidate.id === projectId) ?? initialProject;
+  const repoStateQuery = useRepoStateQuery(project);
+  const pullRequestsQuery = useProjectPullRequestsQuery(project);
+  const initialSyncQuery = useProjectRepoSyncStatusQuery(
+    project,
+    reposDir,
+    project?.defaultBranch,
+  );
+  const branchOptions = React.useMemo(() => {
+    const names = [
+      project?.defaultBranch,
+      ...(repoStateQuery.data?.branches.map((branch) => branch.name) ?? []),
+      initialSyncQuery.data?.localBranch,
+    ].filter((name): name is string => Boolean(name));
+    return [...new Set(names)];
+  }, [
+    initialSyncQuery.data?.localBranch,
+    project?.defaultBranch,
+    repoStateQuery.data?.branches,
+  ]);
+  const [targetBranch, setTargetBranch] = React.useState(
+    project?.defaultBranch ?? "",
+  );
+  const [sourceBranch, setSourceBranch] = React.useState("");
+  const sourceSyncQuery = useProjectRepoSyncStatusQuery(
+    project,
+    reposDir,
+    sourceBranch || null,
+    targetBranch || null,
+  );
+  const createMutation = useCreateProjectPullRequestMutation(project);
+
+  React.useEffect(() => {
+    if (!open) return;
+    const nextProject =
+      projects.find((candidate) => candidate.id === initialProjectId) ??
+      projects[0];
+    setProjectId(nextProject?.id ?? "");
+  }, [initialProjectId, open, projects]);
+
+  React.useEffect(() => {
+    if (!project) return;
+    setTargetBranch(project.defaultBranch);
+    setSourceBranch("");
+  }, [project]);
+
+  React.useEffect(() => {
+    if (
+      sourceBranch &&
+      branchOptions.includes(sourceBranch) &&
+      sourceBranch !== targetBranch
+    ) {
+      return;
+    }
+    setSourceBranch(
+      branchOptions.find((branch) => branch !== targetBranch) ?? "",
+    );
+  }, [branchOptions, sourceBranch, targetBranch]);
+
+  const sourceCommit =
+    repoStateQuery.data?.branches.find((branch) => branch.name === sourceBranch)
+      ?.commit ??
+    (sourceSyncQuery.data?.remoteBranch === sourceBranch
+      ? sourceSyncQuery.data.remoteHead
+      : null);
+  const hasOpenPullRequest = (pullRequestsQuery.data ?? []).some(
+    (pullRequest) =>
+      (pullRequest.status === "Open" || pullRequest.status === "Draft") &&
+      pullRequest.branchName === sourceBranch &&
+      (pullRequest.targetBranch ?? project?.defaultBranch) === targetBranch,
+  );
+  const selectionError = !project
+    ? "Choose a repository."
+    : !targetBranch
+      ? "Choose a base branch."
+      : !sourceBranch
+        ? "Choose a compare branch."
+        : sourceBranch === targetBranch
+          ? "The base and compare branches must be different."
+          : hasOpenPullRequest
+            ? "An open pull request already compares these branches."
+            : !sourceCommit
+              ? "The compare branch must be pushed before opening a pull request."
+              : null;
+  const description =
+    project && sourceBranch && targetBranch
+      ? `${project.name}: ${sourceBranch} → ${targetBranch}${sourceCommit ? ` at ${sourceCommit.slice(0, 7)}` : ""}`
+      : "Choose a repository and branches to compare.";
+
+  async function handleCreate(input: CreatePullRequestDialogInput) {
+    if (!project || !sourceCommit || selectionError) {
+      throw new Error(
+        selectionError ?? "Pull request branches are incomplete.",
+      );
+    }
+    const pullRequestId = await createMutation.mutateAsync({
+      ...input,
+      branch: sourceBranch,
+      targetBranch,
+      commit: sourceCommit,
+      mergeBase: sourceSyncQuery.data?.mergeBase ?? null,
+      reviewers: [],
+    });
+    toast.success("Pull request created.");
+    await onCreated(project, pullRequestId);
+  }
+
+  return (
+    <CreateProjectWorkItemDialog
+      bodyPlaceholder="Add context for reviewers"
+      description={description}
+      isCreating={createMutation.isPending}
+      itemName="pull-request"
+      onCreate={handleCreate}
+      onOpenChange={(nextOpen) => {
+        if (!nextOpen && createMutation.isPending) return;
+        onOpenChange(nextOpen);
+      }}
+      open={open}
+      submitDisabled={Boolean(selectionError)}
+      title="Open a pull request"
+      titlePlaceholder="Describe the change"
+    >
+      <div className="grid gap-3 rounded-xl border border-border/60 bg-muted/25 p-3 sm:grid-cols-2">
+        <label className="space-y-1.5 text-sm font-medium sm:col-span-2">
+          <span>Repository</span>
+          <select
+            className="h-10 w-full rounded-lg border border-input bg-background px-3 text-sm font-normal outline-hidden focus:ring-1 focus:ring-ring"
+            data-testid="create-pull-request-repository"
+            disabled={createMutation.isPending}
+            onChange={(event) => setProjectId(event.target.value)}
+            value={project?.id ?? ""}
+          >
+            {projects.map((candidate) => (
+              <option key={candidate.id} value={candidate.id}>
+                {candidate.name}
+              </option>
+            ))}
+          </select>
+        </label>
+        <label className="space-y-1.5 text-sm font-medium">
+          <span>Base</span>
+          <select
+            className="h-10 w-full rounded-lg border border-input bg-background px-3 text-sm font-normal outline-hidden focus:ring-1 focus:ring-ring"
+            data-testid="create-pull-request-base-branch"
+            disabled={createMutation.isPending}
+            onChange={(event) => setTargetBranch(event.target.value)}
+            value={targetBranch}
+          >
+            {branchOptions.map((branch) => (
+              <option key={branch} value={branch}>
+                {branch}
+              </option>
+            ))}
+          </select>
+        </label>
+        <label className="space-y-1.5 text-sm font-medium">
+          <span>Compare</span>
+          <select
+            className="h-10 w-full rounded-lg border border-input bg-background px-3 text-sm font-normal outline-hidden focus:ring-1 focus:ring-ring"
+            data-testid="create-pull-request-compare-branch"
+            disabled={createMutation.isPending}
+            onChange={(event) => setSourceBranch(event.target.value)}
+            value={sourceBranch}
+          >
+            <option disabled value="">
+              Select branch
+            </option>
+            {branchOptions.map((branch) => (
+              <option key={branch} value={branch}>
+                {branch}
+              </option>
+            ))}
+          </select>
+        </label>
+        {selectionError ? (
+          <p className="text-xs text-muted-foreground sm:col-span-2">
+            {selectionError}
+          </p>
+        ) : null}
+      </div>
+    </CreateProjectWorkItemDialog>
+  );
+}
diff --git a/desktop/src/features/projects/ui/MergePullRequestButton.tsx b/desktop/src/features/projects/ui/MergePullRequestButton.tsx
new file mode 100644
index 0000000000..80f694c8de
--- /dev/null
+++ b/desktop/src/features/projects/ui/MergePullRequestButton.tsx
@@ -0,0 +1,129 @@
+import { GitMerge } from "lucide-react";
+import * as React from "react";
+import { toast } from "sonner";
+
+import type { Project, ProjectPullRequest } from "@/features/projects/hooks";
+import {
+  useMergeProjectPullRequestMutation,
+  usePublishProjectPullRequestMergedMutation,
+} from "@/features/projects/pullRequestMutations";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/shared/ui/alert-dialog";
+import { Button } from "@/shared/ui/button";
+
+export function MergePullRequestButton({
+  project,
+  pullRequest,
+}: {
+  project: Project;
+  pullRequest: ProjectPullRequest;
+}) {
+  const [confirmOpen, setConfirmOpen] = React.useState(false);
+  const [unpublishedStatusEvent, setUnpublishedStatusEvent] = React.useState<
+    string | null
+  >(null);
+  const mergeMutation = useMergeProjectPullRequestMutation(project);
+  const publishMergedMutation =
+    usePublishProjectPullRequestMergedMutation(project);
+  const targetBranch = pullRequest.targetBranch ?? project.defaultBranch;
+
+  const handleMerge = React.useCallback(async () => {
+    try {
+      const result = await mergeMutation.mutateAsync({ pullRequest });
+      if (result.statusPublicationError) {
+        setUnpublishedStatusEvent(result.statusEvent);
+        toast.warning(result.message, {
+          description: result.statusPublicationError,
+        });
+      } else {
+        setUnpublishedStatusEvent(null);
+        toast.success(result.message);
+      }
+      setConfirmOpen(false);
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : "Failed to merge pull request.",
+      );
+    }
+  }, [mergeMutation, pullRequest]);
+
+  const handlePublishMergedStatus = React.useCallback(async () => {
+    if (!unpublishedStatusEvent) return;
+    try {
+      await publishMergedMutation.mutateAsync({
+        statusEvent: unpublishedStatusEvent,
+      });
+      setUnpublishedStatusEvent(null);
+      toast.success("Published merged pull request status.");
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : "Failed to publish merged pull request status.",
+      );
+    }
+  }, [publishMergedMutation, unpublishedStatusEvent]);
+
+  return (
+    <AlertDialog onOpenChange={setConfirmOpen} open={confirmOpen}>
+      <Button
+        className="h-8 gap-1.5 bg-purple-600 px-3.5 text-white shadow-sm hover:bg-purple-700"
+        disabled={mergeMutation.isPending || publishMergedMutation.isPending}
+        onClick={() => {
+          if (unpublishedStatusEvent) {
+            void handlePublishMergedStatus();
+          } else {
+            setConfirmOpen(true);
+          }
+        }}
+        size="xs"
+        type="button"
+      >
+        <GitMerge className="h-3.5 w-3.5" />
+        {publishMergedMutation.isPending
+          ? "Publishing…"
+          : unpublishedStatusEvent
+            ? "Publish merged status"
+            : "Merge"}
+      </Button>
+      <AlertDialogContent data-testid="merge-pull-request-confirm">
+        <AlertDialogHeader>
+          <AlertDialogTitle>Merge pull request?</AlertDialogTitle>
+          <AlertDialogDescription>
+            Merge {pullRequest.branchName} into {targetBranch} and push the
+            result to the repository. The remote will reject the operation if
+            the branch changed or conflicts.
+          </AlertDialogDescription>
+        </AlertDialogHeader>
+        <AlertDialogFooter>
+          <AlertDialogCancel disabled={mergeMutation.isPending}>
+            Cancel
+          </AlertDialogCancel>
+          <AlertDialogAction asChild>
+            <Button
+              data-testid="merge-pull-request-confirm-button"
+              disabled={mergeMutation.isPending}
+              onClick={(event) => {
+                event.preventDefault();
+                void handleMerge();
+              }}
+              type="button"
+            >
+              {mergeMutation.isPending ? "Merging…" : "Merge pull request"}
+            </Button>
+          </AlertDialogAction>
+        </AlertDialogFooter>
+      </AlertDialogContent>
+    </AlertDialog>
+  );
+}
diff --git a/desktop/src/features/projects/ui/ProjectCards.tsx b/desktop/src/features/projects/ui/ProjectCards.tsx
index 2681866880..52308f7a05 100644
--- a/desktop/src/features/projects/ui/ProjectCards.tsx
+++ b/desktop/src/features/projects/ui/ProjectCards.tsx
@@ -3,7 +3,6 @@ import {
   FolderGit2,
   GitCommit,
   GitPullRequest,
-  MoreHorizontal,
   TerminalSquare,
   Trash2,
 } from "lucide-react";
@@ -24,6 +23,14 @@ import {
   relativeTime,
 } from "@/features/projects/lib/projectsViewHelpers";
 import { projectTerminalLabel } from "@/features/projects/ui/useOpenProjectTerminal";
+import {
+  PROJECT_LIST_ROW_CLASS,
+  PROJECT_LIST_ROW_DATE_CLASS,
+  PROJECT_LIST_ROW_META_TEXT_CLASS,
+  PROJECT_LIST_ROW_PREVIEW_CLASS,
+  PROJECT_LIST_ROW_TITLE_CLASS,
+  PROJECT_LIST_ROW_TRAILING_CLASS,
+} from "@/features/projects/ui/projectListRowStyles";
 import { cn } from "@/shared/lib/cn";
 import { normalizePubkey } from "@/shared/lib/pubkey";
 import {
@@ -38,14 +45,10 @@ import {
 } from "@/shared/ui/alert-dialog";
 import { Button } from "@/shared/ui/button";
 import { Card } from "@/shared/ui/card";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuTrigger,
-} from "@/shared/ui/dropdown-menu";
+import { DropdownMenuItem } from "@/shared/ui/dropdown-menu";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
+import { ProjectListRowMenu } from "./ProjectListRowMenu";
 
 function ProjectUpdatedLabel({
   profiles,
@@ -65,7 +68,7 @@ function ProjectUpdatedLabel({
   return (
     <Tooltip>
       <TooltipTrigger asChild>
-        <span className="whitespace-nowrap text-xs text-muted-foreground">
+        <span className="whitespace-nowrap text-xs leading-4 text-muted-foreground/70">
           {relativeTime(updatedAt)}
         </span>
       </TooltipTrigger>
@@ -175,7 +178,8 @@ function ProjectStatsRow({
   return (
     <div
       className={cn(
-        "flex items-center gap-x-3 gap-y-1 text-xs text-muted-foreground",
+        "flex items-center gap-x-3 gap-y-1 text-muted-foreground",
+        fixedColumns ? PROJECT_LIST_ROW_META_TEXT_CLASS : "text-xs leading-4",
         !fixedColumns && "flex-wrap",
       )}
     >
@@ -326,46 +330,32 @@ function ProjectActionsMenu({
 
   return (
     <AlertDialog onOpenChange={setConfirmOpen} open={confirmOpen}>
-      <DropdownMenu modal={false}>
-        <DropdownMenuTrigger asChild>
-          <Button
-            aria-label={`More options for ${project.name}`}
-            className="relative z-20 h-7 w-7 text-muted-foreground hover:text-foreground"
-            onClick={(event) => event.stopPropagation()}
-            size="icon"
-            type="button"
-            variant="ghost"
-          >
-            <MoreHorizontal className="h-4 w-4" />
-          </Button>
-        </DropdownMenuTrigger>
-        <DropdownMenuContent align="end" className="min-w-48">
-          <DropdownMenuItem
-            onSelect={(event) => {
-              event.preventDefault();
-              event.stopPropagation();
-              void onOpenTerminal(project);
-            }}
-          >
-            <TerminalSquare className="h-4 w-4" />
-            {projectTerminalLabel(hasLocal)}
-          </DropdownMenuItem>
-          <DropdownMenuItem
-            className="text-destructive focus:text-destructive"
-            disabled={!canDelete || disabled}
-            onSelect={(event) => {
-              event.preventDefault();
-              event.stopPropagation();
-              if (canDelete && !disabled) {
-                setConfirmOpen(true);
-              }
-            }}
-          >
-            <Trash2 className="h-4 w-4" />
-            Delete project
-          </DropdownMenuItem>
-        </DropdownMenuContent>
-      </DropdownMenu>
+      <ProjectListRowMenu label={`More options for ${project.name}`}>
+        <DropdownMenuItem
+          onSelect={(event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            void onOpenTerminal(project);
+          }}
+        >
+          <TerminalSquare className="h-4 w-4" />
+          {projectTerminalLabel(hasLocal)}
+        </DropdownMenuItem>
+        <DropdownMenuItem
+          className="text-destructive focus:text-destructive"
+          disabled={!canDelete || disabled}
+          onSelect={(event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            if (canDelete && !disabled) {
+              setConfirmOpen(true);
+            }
+          }}
+        >
+          <Trash2 className="h-4 w-4" />
+          Delete project
+        </DropdownMenuItem>
+      </ProjectListRowMenu>
       <AlertDialogContent
         data-testid={`project-delete-confirm-${project.dtag}`}
       >
@@ -502,43 +492,52 @@ export function ProjectListRow({
 }: ProjectItemProps) {
   return (
     <div
-      className="group relative px-4 py-2.5 transition-colors duration-150 hover:bg-muted/20"
+      className={cn(PROJECT_LIST_ROW_CLASS, "py-3")}
       data-testid={`project-row-${project.dtag}`}
     >
       <ProjectCardButton onOpen={onOpen} project={project} />
-      <div className="flex min-w-0 items-center justify-between gap-3">
-        <div className="flex min-w-0 items-center gap-2">
+      <div className="flex min-w-0 items-start gap-2.5">
+        <div className="flex min-w-0 flex-1 items-start gap-2.5">
           <span className="flex h-9 w-9 shrink-0 items-center justify-center rounded-lg border border-border/60 bg-muted/40">
             <FolderGit2 className="h-4.5 w-4.5 text-muted-foreground" />
           </span>
-          <div className="min-w-0">
+          <div className="-mt-0.5 min-w-0">
             <div className="flex min-w-0 items-center gap-2">
-              <span className="truncate text-sm font-semibold text-foreground">
+              <span className={PROJECT_LIST_ROW_TITLE_CLASS}>
                 {project.name}
               </span>
               <StatusPill status={project.status} />
             </div>
-            <p className="line-clamp-1 text-sm text-muted-foreground">
+            <p className={PROJECT_LIST_ROW_PREVIEW_CLASS}>
               {project.description || "A shared space for internal git work."}
             </p>
           </div>
         </div>
 
-        <div className="relative z-10 flex shrink-0 items-center gap-3">
-          <div className="hidden items-center gap-3 md:flex">
+        <div className={PROJECT_LIST_ROW_TRAILING_CLASS}>
+          <div
+            className="hidden items-center gap-3 xl:flex"
+            data-testid="projects-row-summary"
+          >
             <ProjectStatsRow fixedColumns summary={summary} />
             <div className="w-20 shrink-0">
               <ProjectActivityBar summary={summary} />
             </div>
           </div>
-          <div className="flex w-24 shrink-0 justify-end">
+          <div
+            className="hidden w-24 shrink-0 justify-end lg:flex"
+            data-testid="projects-row-people"
+          >
             <ProjectPeopleStack
               profiles={profiles}
               pubkeys={people}
               workOwnerPubkey={project.owner}
             />
           </div>
-          <div className="hidden w-24 shrink-0 text-right sm:block">
+          <div
+            className={PROJECT_LIST_ROW_DATE_CLASS}
+            data-testid="projects-row-date"
+          >
             <ProjectUpdatedLabel
               profiles={profiles}
               project={project}
diff --git a/desktop/src/features/projects/ui/ProjectDetailFeedPanels.tsx b/desktop/src/features/projects/ui/ProjectDetailFeedPanels.tsx
index cb96b835d8..ffbde13270 100644
--- a/desktop/src/features/projects/ui/ProjectDetailFeedPanels.tsx
+++ b/desktop/src/features/projects/ui/ProjectDetailFeedPanels.tsx
@@ -15,7 +15,7 @@ import {
   resolveUserLabel,
   type UserProfileLookup,
 } from "@/features/profile/lib/identity";
-import { GitCommitHorizontal } from "lucide-react";
+import { GitBranch, GitCommitHorizontal } from "lucide-react";
 
 import { cn } from "@/shared/lib/cn";
 import { CopyCommitHashButton } from "./ProjectCommitCopyButton";
@@ -141,29 +141,8 @@ export function ContributorsPanel({
   );
 }
 
-function commitDayLabel(timestamp: number) {
-  return new Date(timestamp * 1_000).toLocaleDateString(undefined, {
-    month: "short",
-    day: "numeric",
-    year: "numeric",
-  });
-}
-
-function groupCommitsByDay(commits: ProjectRepoCommit[]) {
-  const groups: { label: string; commits: ProjectRepoCommit[] }[] = [];
-  for (const commit of commits) {
-    const label = commitDayLabel(commit.timestamp);
-    const lastGroup = groups[groups.length - 1];
-    if (lastGroup && lastGroup.label === label) {
-      lastGroup.commits.push(commit);
-    } else {
-      groups.push({ label, commits: [commit] });
-    }
-  }
-  return groups;
-}
-
 export function ActivityPanel({
+  branch,
   snapshot,
   isLoading,
   error,
@@ -173,6 +152,7 @@ export function ActivityPanel({
   repoContributors,
   viewerGitIdentity,
 }: {
+  branch?: string;
   snapshot: ProjectRepoSnapshot | null | undefined;
   isLoading: boolean;
   error: unknown;
@@ -205,107 +185,98 @@ export function ActivityPanel({
     );
   }
 
-  const groups = groupCommitsByDay(commits);
-
   return (
-    <div className="relative space-y-5">
-      {/* Timeline rail connecting the date group markers, GitHub-style. */}
-      <div
-        aria-hidden="true"
-        className="absolute bottom-2 left-[7px] top-2 w-px bg-border/45"
-      />
-      {groups.map((group) => (
-        <section className="relative pl-7" key={group.label}>
-          <span className="absolute left-0 top-0.5 flex h-4 w-4 items-center justify-center rounded-full bg-background ring-1 ring-border/60">
-            <GitCommitHorizontal className="h-3 w-3 text-muted-foreground/80" />
-          </span>
-          <h3 className="text-xs font-medium text-muted-foreground">
-            Commits on {group.label}
-          </h3>
-          <div className="relative mt-2">
-            {/* Stub linking the timeline rail to the commit box. */}
-            <span
-              aria-hidden="true"
-              className="absolute top-8 -left-[1.3125rem] h-px w-[1.3125rem] bg-border/60"
-            />
-            <div className="divide-y divide-border/50 overflow-hidden rounded-xl border border-border/60 bg-card">
-              {group.commits.map((commit) => {
-                const matchedProfile = profileForCommit(
-                  commit,
-                  profiles,
-                  commitAuthorPubkeys,
-                  viewerGitIdentity,
-                );
-                const authorLabel = matchedProfile
-                  ? resolveUserLabel({
-                      pubkey: matchedProfile.pubkey,
-                      profiles,
-                    })
-                  : commit.authorName || commit.authorEmail || "Unknown author";
-                const matchingContributor = repoContributors.find(
-                  (contributor) =>
-                    contributor.name.trim().toLowerCase() ===
-                      commit.authorName.trim().toLowerCase() ||
-                    contributor.email.trim().toLowerCase() ===
-                      commit.authorEmail.trim().toLowerCase(),
-                );
+    <section className="overflow-hidden rounded-xl border border-border/60 bg-card">
+      <div className="flex min-h-14 items-center gap-2 border-border/50 border-b px-4 py-3">
+        <GitCommitHorizontal className="h-4 w-4 text-muted-foreground" />
+        <h3 className="min-w-0 flex-1 truncate text-sm font-medium text-foreground">
+          Commits
+        </h3>
+      </div>
+      <div className="divide-y divide-border/50">
+        {commits.map((commit) => {
+          const matchedProfile = profileForCommit(
+            commit,
+            profiles,
+            commitAuthorPubkeys,
+            viewerGitIdentity,
+          );
+          const authorLabel = matchedProfile
+            ? resolveUserLabel({
+                pubkey: matchedProfile.pubkey,
+                profiles,
+              })
+            : commit.authorName || commit.authorEmail || "Unknown author";
+          const matchingContributor = repoContributors.find(
+            (contributor) =>
+              contributor.name.trim().toLowerCase() ===
+                commit.authorName.trim().toLowerCase() ||
+              contributor.email.trim().toLowerCase() ===
+                commit.authorEmail.trim().toLowerCase(),
+          );
 
-                return (
-                  <ProjectFeedRow
-                    key={commit.hash}
-                    meta={
-                      <>
-                        <ProfileIdentityButton
-                          avatarClassName="shrink-0"
-                          avatarSize="xs"
-                          avatarUrl={matchedProfile?.profile.avatarUrl ?? null}
-                          isAgent={matchedProfile?.profile.isAgent === true}
-                          label={authorLabel}
-                          pubkey={matchedProfile?.pubkey ?? null}
-                          showLabel={false}
-                        />
-                        <span className="truncate font-medium text-foreground/80">
-                          {authorLabel}
-                        </span>
-                        <span>
-                          authored {relativeCommitTime(commit.timestamp)}
-                        </span>
-                        {matchingContributor?.commitCount ? (
-                          <span className="rounded-full border border-border/60 px-1.5 py-0.5 text-2xs">
-                            {pluralize(
-                              matchingContributor.commitCount,
-                              "commit",
-                            )}
-                          </span>
-                        ) : null}
-                      </>
-                    }
-                    onOpen={
-                      onSelectCommit ? () => onSelectCommit(commit) : undefined
-                    }
-                    testId="project-activity-feed-item"
-                    title={commit.subject}
-                    trailing={
-                      <ProjectFeedRowCluster>
-                        <ProjectFeedRowMonoCell
-                          label={commit.shortHash}
-                          onClick={
-                            onSelectCommit
-                              ? () => onSelectCommit(commit)
-                              : undefined
-                          }
-                          title={`View commit ${commit.shortHash}`}
-                        />
-                        <CopyCommitHashButton hash={commit.hash} />
-                      </ProjectFeedRowCluster>
-                    }
+          return (
+            <ProjectFeedRow
+              key={commit.hash}
+              meta={
+                <>
+                  <ProfileIdentityButton
+                    avatarClassName="shrink-0"
+                    avatarSize="xs"
+                    avatarUrl={matchedProfile?.profile.avatarUrl ?? null}
+                    isAgent={matchedProfile?.profile.isAgent === true}
+                    label={authorLabel}
+                    pubkey={matchedProfile?.pubkey ?? null}
+                    showLabel={false}
                   />
-                );
-              })}
-            </div>
-          </div>
-        </section>
-      ))}
-    </div>
+                  <span className="truncate">
+                    <span className="font-medium text-foreground/80">
+                      {authorLabel}
+                    </span>{" "}
+                    committed
+                  </span>
+                  {branch ? (
+                    <span className="inline-flex min-w-0 items-center gap-1 rounded-full border border-border/60 px-1.5 py-0.5 font-mono text-2xs">
+                      <GitBranch className="h-3 w-3 shrink-0" />
+                      <span className="truncate">{branch}</span>
+                    </span>
+                  ) : null}
+                  {matchingContributor?.commitCount ? (
+                    <span className="rounded-full border border-border/60 px-1.5 py-0.5 text-2xs">
+                      {pluralize(matchingContributor.commitCount, "commit")}
+                    </span>
+                  ) : null}
+                </>
+              }
+              onOpen={onSelectCommit ? () => onSelectCommit(commit) : undefined}
+              testId="project-activity-feed-item"
+              title={commit.subject}
+              trailing={
+                <>
+                  <span
+                    className="hidden w-20 shrink-0 text-right text-xs text-muted-foreground sm:block"
+                    title={new Date(commit.timestamp * 1_000).toLocaleString()}
+                  >
+                    {relativeCommitTime(commit.timestamp)}
+                  </span>
+                  <ProjectFeedRowCluster>
+                    <ProjectFeedRowMonoCell
+                      label={commit.shortHash}
+                      onClick={
+                        onSelectCommit
+                          ? () => onSelectCommit(commit)
+                          : undefined
+                      }
+                      title={`View commit ${commit.shortHash}`}
+                    />
+                    <CopyCommitHashButton hash={commit.hash} />
+                  </ProjectFeedRowCluster>
+                </>
+              }
+            />
+          );
+        })}
+      </div>
+    </section>
   );
 }
diff --git a/desktop/src/features/projects/ui/ProjectDetailScreen.tsx b/desktop/src/features/projects/ui/ProjectDetailScreen.tsx
index 433ec76c17..60c8ac965c 100644
--- a/desktop/src/features/projects/ui/ProjectDetailScreen.tsx
+++ b/desktop/src/features/projects/ui/ProjectDetailScreen.tsx
@@ -12,7 +12,6 @@ import { useAppNavigation } from "@/app/navigation/useAppNavigation";
 import { useOpenDmMutation } from "@/features/channels/hooks";
 import {
   type Project,
-  type ProjectRepoSnapshot,
   useProjectQuery,
   useProjectIssuesQuery,
   useProjectLocalRepoDiffQuery,
@@ -20,13 +19,17 @@ import {
   useProjectRepoDiffQuery,
   useProjectPullRequestsQuery,
   useProjectRepoSnapshotQuery,
+  useProjectsQuery,
   useRepoStateQuery,
 } from "@/features/projects/hooks";
 import {
+  useCloneProjectRepositoryMutation,
   useProjectRepoSyncStatusQuery,
   usePullProjectLocalRepositoryMutation,
   usePushProjectLocalRepositoryMutation,
 } from "@/features/projects/repoSyncHooks";
+import { useUpdateProjectPullRequestMutation } from "@/features/projects/pullRequestMutations";
+import { useCreateProjectIssueMutation } from "@/features/projects/issueMutations";
 import { useProfileQuery, useUsersBatchQuery } from "@/features/profile/hooks";
 import { mergeCurrentProfileIntoLookup } from "@/features/profile/lib/identity";
 import {
@@ -47,54 +50,28 @@ import {
 } from "@/shared/layout/chromeLayout";
 import { useMeasuredCssVariable } from "@/shared/layout/useMeasuredCssVariable";
 import { cn } from "@/shared/lib/cn";
-import { normalizePubkey } from "@/shared/lib/pubkey";
 import { isSafeUrl } from "@/shared/lib/url";
 import { ProfilePanelProvider } from "@/shared/context/ProfilePanelContext";
 import { useHistorySearchState } from "@/shared/hooks/useHistorySearchState";
 import { useThreadPanelWidth } from "@/shared/hooks/useThreadPanelWidth";
 import { Button } from "@/shared/ui/button";
-import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 import { useCommunities } from "@/features/communities/useCommunities";
 import { useProjectCommitDiffQuery } from "@/features/projects/useProjectCommitDiff";
 import { useGitIdentityQuery } from "@/features/projects/useGitIdentity";
 import type { ViewerGitIdentity } from "@/features/projects/lib/projectContributorMatching";
+import { normalizeRepositoryUrl } from "@/features/projects/lib/projectsViewHelpers";
 import { WorkspaceTabs } from "./ProjectWorkspaceTabs";
 import type { RepoSourceHeaderControls } from "./ProjectRepositorySource";
 import {
   projectTerminalLabel,
   useOpenProjectTerminal,
 } from "./useOpenProjectTerminal";
-import { CopyTextButton } from "./ProjectCommitCopyButton";
-
-/** Tooltip for the push/pull sync buttons, e.g. "Pull 2 remote commits". */
-function pushPullTitle(
-  verb: "Push" | "Pull",
-  count: number | undefined,
-  side: "local" | "remote",
-) {
-  if (!count) return `${verb} ${side} commits`;
-  return `${verb} ${count} ${side} ${count === 1 ? "commit" : "commits"}`;
-}
-
-function projectPeople(project: Project) {
-  return [
-    ...new Set(
-      [project.owner, ...project.contributors]
-        .filter(Boolean)
-        .map(normalizePubkey),
-    ),
-  ];
-}
-
-function snapshotHasContent(snapshot: ProjectRepoSnapshot | null | undefined) {
-  return Boolean(
-    snapshot &&
-      (snapshot.latestCommit ||
-        snapshot.commits.length > 0 ||
-        snapshot.files.length > 0 ||
-        snapshot.contributors.length > 0),
-  );
-}
+import type { CreateIssueDialogInput } from "./CreateIssueDialog";
+import {
+  projectPeople,
+  pushPullTitle,
+  snapshotHasContent,
+} from "./projectDetailHelpers";
 
 type ProjectDetailScreenProps = {
   commitHash?: string;
@@ -111,7 +88,7 @@ const PROJECT_DETAIL_PANEL_SEARCH_KEYS = [
 
 export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
   const { commitHash, projectId, pullRequestId, issueId } = props;
-  const { goChannel, goProjects } = useAppNavigation();
+  const { goChannel, goProject, goProjects } = useAppNavigation();
   const { activeCommunity } = useCommunities();
   const mainInsetRef = useMainInsetRef();
   const projectDetailHeaderChromeRef = useMeasuredCssVariable({
@@ -120,6 +97,7 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
     ...channelContentTopPaddingMeasurement,
   });
   const projectQuery = useProjectQuery(projectId);
+  const projectsQuery = useProjectsQuery();
   const project = projectQuery.data;
   const repoStateQuery = useRepoStateQuery(project);
   const pullRequestsQuery = useProjectPullRequestsQuery(project);
@@ -190,13 +168,25 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
     [],
   );
   const issuesQuery = useProjectIssuesQuery(project);
-  const selectedBranchPullRequest = React.useMemo(
-    () =>
-      pullRequestsQuery.data?.find(
-        (pullRequest) => pullRequest.branchName === activeBranch,
-      ) ?? null,
-    [activeBranch, pullRequestsQuery.data],
-  );
+  const selectedBranchPullRequest = React.useMemo(() => {
+    const projectRepositories = new Set(
+      (project?.cloneUrls ?? []).map(normalizeRepositoryUrl),
+    );
+    const matches =
+      pullRequestsQuery.data?.filter(
+        (pullRequest) =>
+          pullRequest.branchName === activeBranch &&
+          pullRequest.cloneUrls.some((cloneUrl) =>
+            projectRepositories.has(normalizeRepositoryUrl(cloneUrl)),
+          ),
+      ) ?? [];
+    return matches.length === 1 ? matches[0] : null;
+  }, [activeBranch, project?.cloneUrls, pullRequestsQuery.data]);
+  const openBranchPullRequest =
+    selectedBranchPullRequest?.status === "Open" ||
+    selectedBranchPullRequest?.status === "Draft"
+      ? selectedBranchPullRequest
+      : null;
   const activeRepoPullRequest =
     pullRequestsQuery.data?.find((item) => item.id === selectedPullRequestId) ??
     selectedBranchPullRequest;
@@ -241,12 +231,22 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
     project,
     activeCommunity?.reposDir,
     activeBranch,
+    openBranchPullRequest,
   );
   const pullLocalRepoMutation = usePullProjectLocalRepositoryMutation(
     project,
     activeCommunity?.reposDir,
     activeBranch,
   );
+  const cloneRepoMutation = useCloneProjectRepositoryMutation(
+    project,
+    activeCommunity?.reposDir,
+  );
+  const createIssueMutation = useCreateProjectIssueMutation(project);
+  const updatePullRequestMutation = useUpdateProjectPullRequestMutation(
+    project,
+    openBranchPullRequest,
+  );
   const hasLocalCheckout = Boolean(
     localRepoSnapshotQuery.data || repoSyncStatusQuery.data?.localPath,
   );
@@ -259,11 +259,35 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
     repoSource === "local"
       ? localRepoDiffQuery.isLoading
       : repoDiffQuery.isLoading;
-  // Compact branch + remote/local controls shared by the readme and Code
+  const branchOptionsWithLocal = React.useMemo(
+    () => [
+      ...new Set(
+        [...branchOptions, repoSyncStatusQuery.data?.localBranch].filter(
+          (branch): branch is string => Boolean(branch),
+        ),
+      ),
+    ],
+    [branchOptions, repoSyncStatusQuery.data?.localBranch],
+  );
+  const handleFetchRepo = React.useCallback(async () => {
+    const results = await Promise.all([
+      repoSnapshotQuery.refetch(),
+      repoStateQuery.refetch(),
+      repoSyncStatusQuery.refetch(),
+    ]);
+    const error = results.find((result) => result.error)?.error;
+    if (error) {
+      toast.error("Could not fetch repository.", {
+        description:
+          error instanceof Error ? error.message : "The Git fetch failed.",
+      });
+    }
+  }, [repoSnapshotQuery, repoStateQuery, repoSyncStatusQuery]);
+  // Compact branch + remote/local controls shared by the readme and Files
   // tab headers.
   const filesSourceControls: RepoSourceHeaderControls = {
     branch: activeBranch ?? "",
-    branchOptions,
+    branchOptions: branchOptionsWithLocal,
     onBranchChange: setSelectedBranch,
     source: repoSource,
     onSourceChange: setRepoSource,
@@ -300,9 +324,12 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
     aheadCount: repoSyncStatusQuery.data?.aheadCount ?? null,
     behindCount: repoSyncStatusQuery.data?.behindCount ?? null,
     onFetch: () => {
-      void repoSyncStatusQuery.refetch();
+      void handleFetchRepo();
     },
-    fetchPending: repoSyncStatusQuery.isFetching,
+    fetchPending:
+      repoSnapshotQuery.isFetching ||
+      repoStateQuery.isFetching ||
+      repoSyncStatusQuery.isFetching,
     fetchTitle:
       repoSyncStatusQuery.data?.pullBlockReason ?? "Check for remote changes",
   };
@@ -425,7 +452,17 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
   const handlePushLocalRepo = React.useCallback(async () => {
     try {
       const result = await pushLocalRepoMutation.mutateAsync();
-      toast.success(result.message);
+      if (result.pullRequestUpdate.status === "failed") {
+        toast.warning(result.message, {
+          description: result.pullRequestUpdate.error,
+        });
+      } else {
+        toast.success(
+          result.pullRequestUpdate.status === "updated"
+            ? `${result.message} Pull request updated.`
+            : result.message,
+        );
+      }
       await Promise.all([
         repoSnapshotQuery.refetch(),
         localRepoSnapshotQuery.refetch(),
@@ -444,6 +481,62 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
     repoStateQuery,
     repoSyncStatusQuery,
   ]);
+  const handleCloneRepo = React.useCallback(async () => {
+    try {
+      const result = await cloneRepoMutation.mutateAsync();
+      toast.success(result.message);
+      setRepoSource("local");
+    } catch (error) {
+      toast.error(
+        error instanceof Error ? error.message : "Failed to clone repository",
+      );
+    }
+  }, [cloneRepoMutation]);
+  const handlePullRequestCreated = React.useCallback(
+    async (createdProject: Project, pullRequestId: string) => {
+      if (createdProject.id !== projectId) {
+        await goProject(createdProject.id, { pullRequestId });
+        return;
+      }
+      await pullRequestsQuery.refetch();
+      setSelectedPullRequestId(pullRequestId);
+    },
+    [goProject, projectId, pullRequestsQuery],
+  );
+  const handleCreateIssue = React.useCallback(
+    async ({ body, title }: CreateIssueDialogInput) => {
+      const issueId = await createIssueMutation.mutateAsync({ body, title });
+      toast.success("Issue created.");
+      await issuesQuery.refetch();
+      setSelectedIssueId(issueId);
+    },
+    [createIssueMutation, issuesQuery],
+  );
+  const handleUpdatePullRequest = React.useCallback(async () => {
+    const commit = repoSyncStatusQuery.data?.remoteHead;
+    if (!commit) return;
+    try {
+      const updated = await updatePullRequestMutation.mutateAsync({
+        commit,
+        mergeBase: repoSyncStatusQuery.data?.mergeBase ?? null,
+      });
+      toast.success(
+        updated ? "Pull request updated." : "Pull request is already current.",
+      );
+      await pullRequestsQuery.refetch();
+    } catch (error) {
+      toast.error(
+        error instanceof Error
+          ? error.message
+          : "Failed to update pull request",
+      );
+    }
+  }, [
+    pullRequestsQuery,
+    repoSyncStatusQuery.data?.mergeBase,
+    repoSyncStatusQuery.data?.remoteHead,
+    updatePullRequestMutation,
+  ]);
   const handlePullLocalRepo = React.useCallback(async () => {
     try {
       const result = await pullLocalRepoMutation.mutateAsync();
@@ -550,7 +643,7 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
   // match the workspace tab labels.
   const activeWorkItemCrumb = selectedPullRequest
     ? {
-        category: "PRs",
+        category: "Pull Request",
         title: selectedPullRequest.title,
         clear: () => setSelectedPullRequestId(null),
       }
@@ -569,10 +662,10 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
         : null;
   // Sub-tab crumb when no work item is open. Overview (readme) is home.
   const TAB_CRUMB_LABELS: Record<string, string> = {
-    files: "Code",
+    files: "Files",
     activity: "Commits",
     issues: "Issues",
-    prs: "PRs",
+    prs: "Pull Request",
     contributors: "Contributors",
   };
   const activeTabCrumb = activeWorkItemCrumb
@@ -688,7 +781,7 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
           </div>
 
           <div className="flex min-h-0 min-w-0 flex-1 flex-col overflow-y-auto px-4 pb-4">
-            <div className="w-full space-y-5 pt-[calc(var(--buzz-channel-content-top-padding,5.75rem)_+_1px)]">
+            <div className="w-full space-y-3 pt-[calc(var(--buzz-channel-content-top-padding,5.75rem)_+_1px)]">
               <section className="space-y-3">
                 <div className="flex min-w-0 items-start justify-between gap-3">
                   <div className="min-w-0 flex-1 space-y-0.5">
@@ -715,26 +808,46 @@ export function ProjectDetailScreen(props: ProjectDetailScreenProps) {
                       ) : null}
                     </div>
                   </div>
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <span className="inline-flex shrink-0">
-                        <CopyTextButton
-                          ariaLabel="Copy repo address"
-                          className="h-6 w-6"
-                          text={project.repoAddress}
-                        />
-                      </span>
-                    </TooltipTrigger>
-                    <TooltipContent>Copy repo address</TooltipContent>
-                  </Tooltip>
                 </div>
               </section>
 
               <WorkspaceTabs
                 key={`${project.id}:${tabsResetKey}`}
+                cloneAction={
+                  !hasLocalCheckout && project.cloneUrls[0]
+                    ? {
+                        onClone: () => {
+                          void handleCloneRepo();
+                        },
+                        pending: cloneRepoMutation.isPending,
+                      }
+                    : undefined
+                }
                 commitDiff={commitDiffQuery.data}
                 commitDiffError={commitDiffQuery.error}
                 commitDiffLoading={commitDiffQuery.isLoading}
+                createIssueAction={{
+                  onCreate: handleCreateIssue,
+                  pending: createIssueMutation.isPending,
+                }}
+                createPullRequestAction={{
+                  onCreated: handlePullRequestCreated,
+                  projects: projectsQuery.data ?? [project],
+                  reposDir: activeCommunity?.reposDir,
+                }}
+                updatePullRequestAction={
+                  openBranchPullRequest &&
+                  repoSyncStatusQuery.data?.remoteHead &&
+                  repoSyncStatusQuery.data.remoteHead !==
+                    openBranchPullRequest.commit
+                    ? {
+                        onUpdate: () => {
+                          void handleUpdatePullRequest();
+                        },
+                        pending: updatePullRequestMutation.isPending,
+                      }
+                    : undefined
+                }
                 localSnapshot={localRepoSnapshotQuery.data}
                 localSnapshotError={localRepoSnapshotQuery.error}
                 localSnapshotLoading={localRepoSnapshotQuery.isLoading}
diff --git a/desktop/src/features/projects/ui/ProjectEventTypeIcon.tsx b/desktop/src/features/projects/ui/ProjectEventTypeIcon.tsx
new file mode 100644
index 0000000000..14c7217f2e
--- /dev/null
+++ b/desktop/src/features/projects/ui/ProjectEventTypeIcon.tsx
@@ -0,0 +1,105 @@
+import {
+  Check,
+  CircleDot,
+  FolderGit2,
+  GitCommitHorizontal,
+  GitPullRequest,
+  MessageSquare,
+  UserPlus,
+} from "lucide-react";
+import type { ComponentType } from "react";
+
+import { cn } from "@/shared/lib/cn";
+
+export type ProjectEventKind =
+  | "repository"
+  | "commit"
+  | "pull-request"
+  | "issue"
+  | "comment"
+  | "approval"
+  | "review-request";
+
+export const PROJECT_EVENT_VISUALS: Record<
+  ProjectEventKind,
+  {
+    icon: ComponentType<{ className?: string }>;
+    iconClassName: string;
+    badgeClassName: string;
+    detailClassName: string;
+  }
+> = {
+  repository: {
+    icon: FolderGit2,
+    iconClassName: "text-primary",
+    badgeClassName: "bg-primary/10 text-primary",
+    detailClassName: "border-primary/30 text-primary",
+  },
+  commit: {
+    icon: GitCommitHorizontal,
+    iconClassName: "text-primary",
+    badgeClassName: "bg-primary/10 text-primary",
+    detailClassName: "border-primary/30 text-primary",
+  },
+  "pull-request": {
+    icon: GitPullRequest,
+    iconClassName: "text-green-600 dark:text-green-500",
+    badgeClassName:
+      "bg-green-600/10 text-green-700 dark:bg-green-500/10 dark:text-green-400",
+    detailClassName:
+      "border-green-600/30 text-green-700 dark:border-green-500/30 dark:text-green-400",
+  },
+  issue: {
+    icon: CircleDot,
+    iconClassName: "text-orange-500",
+    badgeClassName: "bg-orange-500/10 text-orange-700 dark:text-orange-300",
+    detailClassName:
+      "border-orange-500/30 text-orange-700 dark:border-orange-500/30 dark:text-orange-300",
+  },
+  comment: {
+    icon: MessageSquare,
+    iconClassName: "text-muted-foreground",
+    badgeClassName: "bg-muted text-muted-foreground",
+    detailClassName: "border-border/60 text-muted-foreground",
+  },
+  approval: {
+    icon: Check,
+    iconClassName: "text-green-600 dark:text-green-500",
+    badgeClassName:
+      "bg-green-600/10 text-green-700 dark:bg-green-500/10 dark:text-green-400",
+    detailClassName:
+      "border-green-600/30 text-green-700 dark:border-green-500/30 dark:text-green-400",
+  },
+  "review-request": {
+    icon: UserPlus,
+    iconClassName: "text-blue-600 dark:text-blue-400",
+    badgeClassName:
+      "bg-blue-600/10 text-blue-700 dark:bg-blue-500/10 dark:text-blue-300",
+    detailClassName:
+      "border-blue-600/30 text-blue-700 dark:border-blue-500/30 dark:text-blue-300",
+  },
+};
+
+export function ProjectEventTypeIcon({
+  className,
+  kind,
+}: {
+  className?: string;
+  kind: ProjectEventKind;
+}) {
+  const visual = PROJECT_EVENT_VISUALS[kind];
+  const Icon = visual.icon;
+
+  return (
+    <span
+      aria-hidden="true"
+      className={cn(
+        "inline-flex h-6 w-6 shrink-0 items-center justify-center rounded-full ring-1 ring-border/60",
+        visual.badgeClassName,
+        className,
+      )}
+    >
+      <Icon className={cn("h-3 w-3", visual.iconClassName)} />
+    </span>
+  );
+}
diff --git a/desktop/src/features/projects/ui/ProjectListRowMenu.tsx b/desktop/src/features/projects/ui/ProjectListRowMenu.tsx
new file mode 100644
index 0000000000..b7f11ca4c2
--- /dev/null
+++ b/desktop/src/features/projects/ui/ProjectListRowMenu.tsx
@@ -0,0 +1,37 @@
+import { MoreHorizontal } from "lucide-react";
+import type * as React from "react";
+
+import { Button } from "@/shared/ui/button";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuTrigger,
+} from "@/shared/ui/dropdown-menu";
+
+export function ProjectListRowMenu({
+  children,
+  label,
+}: {
+  children: React.ReactNode;
+  label: string;
+}) {
+  return (
+    <DropdownMenu modal={false}>
+      <DropdownMenuTrigger asChild>
+        <Button
+          aria-label={label}
+          className="relative z-20 h-7 w-7 text-muted-foreground hover:text-foreground"
+          onClick={(event) => event.stopPropagation()}
+          size="icon"
+          type="button"
+          variant="ghost"
+        >
+          <MoreHorizontal className="h-4 w-4" />
+        </Button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="end" className="min-w-48">
+        {children}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
diff --git a/desktop/src/features/projects/ui/ProjectPullRequestsPanel.tsx b/desktop/src/features/projects/ui/ProjectPullRequestsPanel.tsx
index 8c4d72edf8..7987ec11a5 100644
--- a/desktop/src/features/projects/ui/ProjectPullRequestsPanel.tsx
+++ b/desktop/src/features/projects/ui/ProjectPullRequestsPanel.tsx
@@ -1,5 +1,7 @@
 import {
   Check,
+  GitBranch,
+  GitCommitHorizontal,
   GitMerge,
   GitPullRequest,
   GitPullRequestDraft,
@@ -10,6 +12,7 @@ import {
 import * as React from "react";
 import { toast } from "sonner";
 
+import { useIsManagedAgent } from "@/features/agent-memory/hooks";
 import { ForumComposer } from "@/features/forum/ui/ForumComposer";
 import {
   type Project,
@@ -18,31 +21,28 @@ import {
 } from "@/features/projects/hooks";
 import {
   useApproveProjectPullRequestMutation,
-  useRequestProjectPullRequestReviewMutation,
   useUpdateProjectPullRequestStatusMutation,
 } from "@/features/projects/pullRequestReviews";
+import { relativeTime } from "@/features/projects/lib/projectsViewHelpers";
 import type { UserProfileLookup } from "@/features/profile/lib/identity";
 import { useIdentityQuery } from "@/shared/api/hooks";
 import type { ChannelMember } from "@/shared/api/types";
 import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
-import {
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuLabel,
-  DropdownMenuTrigger,
-} from "@/shared/ui/dropdown-menu";
 import { Markdown } from "@/shared/ui/markdown";
-import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
-import { UserAvatar } from "@/shared/ui/UserAvatar";
 import {
   ProjectFeedRow,
   ProjectFeedRowCluster,
   ProjectFeedRowMonoCell,
 } from "./ProjectFeedRow";
+import { CopyCommitHashButton } from "./ProjectCommitCopyButton";
 import { OverviewRailSection } from "./ProjectOverviewPanel";
-import { ProfileIdentityButton } from "./ProjectProfileIdentity";
+import {
+  ProfileAuthorName,
+  ProfileIdentityButton,
+} from "./ProjectProfileIdentity";
+import { MergePullRequestButton } from "./MergePullRequestButton";
+import { PullRequestReviewersRow } from "./PullRequestReviewersRow";
 
 function compactDate(createdAt: number) {
   return new Date(createdAt * 1_000).toLocaleDateString(undefined, {
@@ -179,6 +179,72 @@ function CommitHashChip({
   );
 }
 
+function PullRequestCommitRow({
+  author,
+  branch,
+  createdAt,
+  hash,
+  message,
+  onOpenCommit,
+  profiles,
+}: {
+  author: string;
+  branch: string | null;
+  createdAt: number;
+  hash: string | null;
+  message: string;
+  onOpenCommit?: (commitHash: string) => void;
+  profiles?: UserProfileLookup;
+}) {
+  const authorProfile = profileForPubkey(author, profiles);
+  const authorLabel = labelForPubkey(author, profiles);
+  const openCommit =
+    hash && onOpenCommit ? () => onOpenCommit(hash) : undefined;
+
+  return (
+    <ProjectFeedRow
+      meta={
+        <>
+          <ProfileIdentityButton
+            avatarClassName="shrink-0"
+            avatarSize="xs"
+            avatarUrl={authorProfile?.avatarUrl ?? null}
+            isAgent={authorProfile?.isAgent === true}
+            label={authorLabel}
+            pubkey={author}
+            showLabel={false}
+          />
+          <span className="truncate">
+            <ProfileAuthorName pubkey={author}>{authorLabel}</ProfileAuthorName>{" "}
+            authored {relativeTime(createdAt)}
+          </span>
+          {branch ? (
+            <span className="inline-flex min-w-0 items-center gap-1 rounded-full border border-border/60 px-1.5 py-0.5 font-mono text-2xs">
+              <GitBranch className="h-3 w-3 shrink-0" />
+              <span className="truncate">{branch}</span>
+            </span>
+          ) : null}
+        </>
+      }
+      onOpen={openCommit}
+      testId="project-pull-request-commit-row"
+      title={message}
+      trailing={
+        hash ? (
+          <ProjectFeedRowCluster>
+            <ProjectFeedRowMonoCell
+              label={hash.slice(0, 7)}
+              onClick={openCommit}
+              title={`View commit ${hash.slice(0, 7)}`}
+            />
+            <CopyCommitHashButton hash={hash} />
+          </ProjectFeedRowCluster>
+        ) : undefined
+      }
+    />
+  );
+}
+
 function PullRequestRow({
   onOpen,
   profiles,
@@ -209,15 +275,23 @@ function PullRequestRow({
             pubkey={pullRequest.author}
             showLabel={false}
           />
-          <span className="truncate font-medium text-foreground/80">
-            {authorLabel}
+          <span className="truncate">
+            <ProfileAuthorName pubkey={pullRequest.author}>
+              {authorLabel}
+            </ProfileAuthorName>{" "}
+            created this pull request {relativeCreatedAt(pullRequest.createdAt)}
           </span>
-          <span>created {relativeCreatedAt(pullRequest.createdAt)}</span>
-          <span className="rounded-full border border-border/60 px-1.5 py-0.5 text-2xs">
-            Member
+          {pullRequest.branchName ? (
+            <span className="inline-flex min-w-0 items-center gap-1 rounded-full border border-border/60 px-1.5 py-0.5 font-mono text-2xs">
+              <GitBranch className="h-3 w-3 shrink-0" />
+              <span className="truncate">{pullRequest.branchName}</span>
+            </span>
+          ) : null}
+          <span
+            className={`rounded-full border border-border/60 px-1.5 py-0.5 text-2xs font-medium ${statusClassName}`}
+          >
+            {pullRequest.status}
           </span>
-          <span>·</span>
-          <span>{pullRequest.status}</span>
         </>
       }
       onOpen={onOpen}
@@ -229,10 +303,15 @@ function PullRequestRow({
       trailing={
         <>
           {pullRequest.comments.length > 0 ? (
-            <span className="flex items-center gap-1 text-xs text-muted-foreground">
+            <button
+              aria-label={`View ${pullRequest.comments.length} comments`}
+              className="flex items-center gap-1 rounded-md text-xs text-muted-foreground hover:text-foreground focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring"
+              onClick={onOpen}
+              type="button"
+            >
               <MessageSquare className="h-3.5 w-3.5" />
               {pullRequest.comments.length}
-            </span>
+            </button>
           ) : null}
           <ProjectFeedRowCluster>
             <ProjectFeedRowMonoCell
@@ -249,144 +328,11 @@ function PullRequestRow({
 
 export type PullRequestPanelMode = "conversation" | "commits" | "checks";
 
-/** Candidate reviewers: project owner, contributors, and PR recipients —
- * minus the PR author and anyone already requested. */
-function reviewerCandidates(project: Project, pullRequest: ProjectPullRequest) {
-  const requested = new Set(pullRequest.reviewers);
-  const author = normalizePubkey(pullRequest.author);
-  return [
-    ...new Set(
-      [project.owner, ...project.contributors, ...pullRequest.recipients].map(
-        normalizePubkey,
-      ),
-    ),
-  ].filter((pubkey) => pubkey !== author && !requested.has(pubkey));
-}
-
-function PullRequestReviewersRow({
-  canRequest,
-  profiles,
-  project,
-  pullRequest,
-}: {
-  canRequest: boolean;
-  profiles?: UserProfileLookup;
-  project: Project;
-  pullRequest: ProjectPullRequest;
-}) {
-  const requestReviewMutation =
-    useRequestProjectPullRequestReviewMutation(project);
-  const candidates = reviewerCandidates(project, pullRequest);
-  const approvedBy = new Set(
-    pullRequest.approvals.map((approval) => normalizePubkey(approval.author)),
-  );
-
-  const handleRequest = React.useCallback(
-    async (pubkey: string) => {
-      try {
-        await requestReviewMutation.mutateAsync({
-          pullRequest,
-          reviewers: [pubkey],
-          reviewerLabel: labelForPubkey(pubkey, profiles),
-        });
-        toast.success("Review requested.");
-      } catch (error) {
-        toast.error(
-          error instanceof Error ? error.message : "Failed to request review.",
-        );
-      }
-    },
-    [profiles, pullRequest, requestReviewMutation],
-  );
-
-  if (pullRequest.reviewers.length === 0 && !canRequest) {
-    return null;
-  }
-
-  return (
-    <div className="flex min-w-0 flex-wrap items-center gap-1.5 px-1 text-xs text-muted-foreground">
-      <span className="font-medium">Reviewers</span>
-      {pullRequest.reviewers.map((pubkey) => {
-        const profile = profileForPubkey(pubkey, profiles);
-        const label = labelForPubkey(pubkey, profiles);
-        const hasApproved = approvedBy.has(normalizePubkey(pubkey));
-        return (
-          <Tooltip key={pubkey}>
-            <TooltipTrigger asChild>
-              <span className="relative inline-flex">
-                <UserAvatar
-                  accent={profile?.isAgent === true}
-                  avatarUrl={profile?.avatarUrl ?? null}
-                  displayName={label}
-                  size="xs"
-                />
-                {hasApproved ? (
-                  <span className="-right-1 -bottom-1 absolute flex h-3.5 w-3.5 items-center justify-center rounded-full bg-green-600 text-white ring-2 ring-background">
-                    <Check className="h-2.5 w-2.5" />
-                  </span>
-                ) : null}
-              </span>
-            </TooltipTrigger>
-            <TooltipContent>
-              {label}
-              {hasApproved ? " — approved" : " — review requested"}
-            </TooltipContent>
-          </Tooltip>
-        );
-      })}
-      {canRequest && candidates.length > 0 ? (
-        <DropdownMenu>
-          <DropdownMenuTrigger asChild>
-            <Button
-              className="h-6 gap-1 px-2 text-2xs text-muted-foreground hover:text-foreground"
-              disabled={requestReviewMutation.isPending}
-              size="xs"
-              type="button"
-              variant="outline"
-            >
-              <UserPlus className="h-3 w-3" />
-              Request
-            </Button>
-          </DropdownMenuTrigger>
-          <DropdownMenuContent align="start" className="min-w-52">
-            <DropdownMenuLabel>Request a review</DropdownMenuLabel>
-            {candidates.map((pubkey) => {
-              const profile = profileForPubkey(pubkey, profiles);
-              const label = labelForPubkey(pubkey, profiles);
-              return (
-                <DropdownMenuItem
-                  key={pubkey}
-                  onSelect={() => {
-                    void handleRequest(pubkey);
-                  }}
-                >
-                  <span className="flex min-w-0 items-center gap-2">
-                    <UserAvatar
-                      accent={profile?.isAgent === true}
-                      avatarUrl={profile?.avatarUrl ?? null}
-                      displayName={label}
-                      size="xs"
-                    />
-                    <span className="truncate">{label}</span>
-                  </span>
-                </DropdownMenuItem>
-              );
-            })}
-          </DropdownMenuContent>
-        </DropdownMenu>
-      ) : null}
-    </div>
-  );
-}
-
-/** GitHub-style review box rendered in the conversation flow, above the
- * comment composer: reviewers on top, review state + actions below. */
+/** GitHub-style review state and actions rendered in the conversation flow. */
 function PullRequestReviewCard({
-  profiles,
   project,
   pullRequest,
 }: {
-  profiles?: UserProfileLookup;
   project: Project;
   pullRequest: ProjectPullRequest;
 }) {
@@ -398,8 +344,8 @@ function PullRequestReviewCard({
   const viewer = viewerPubkey ? normalizePubkey(viewerPubkey) : null;
   const isAuthor = viewer === normalizePubkey(pullRequest.author);
   const isOwner = viewer === normalizePubkey(project.owner);
+  const isManagedAgentOwner = useIsManagedAgent(project.owner) === true;
   const canChangeStatus = Boolean(viewer) && (isAuthor || isOwner);
-  const canRequestReview = canChangeStatus;
   const hasApproved = Boolean(
     viewer &&
       pullRequest.approvals.some(
@@ -411,6 +357,10 @@ function PullRequestReviewCard({
     !isAuthor &&
     !hasApproved &&
     (pullRequest.status === "Open" || pullRequest.status === "Draft");
+  const canMerge =
+    (isOwner || isManagedAgentOwner) &&
+    pullRequest.status === "Open" &&
+    Boolean(pullRequest.branchName && pullRequest.commit);
 
   const handleStatusChange = React.useCallback(
     async (status: "open" | "draft") => {
@@ -445,65 +395,46 @@ function PullRequestReviewCard({
   const isDraft = pullRequest.status === "Draft";
   const reviewState = isDraft
     ? "This pull request is still a work in progress."
-    : approvalCount > 0
-      ? `Approved by ${pluralize(approvalCount, "reviewer")}.`
-      : pullRequest.reviewers.length > 0
-        ? "Review requested — no approvals yet."
-        : "No reviews yet.";
+    : pullRequest.reviewers.length > 0
+      ? "Review requested — no approvals yet."
+      : "No reviews yet.";
   const reviewStateDetail = isDraft
     ? "Draft pull requests cannot be merged."
     : approvalCount === 0
       ? "Approvals from reviewers will show up here."
       : null;
+  const showActions =
+    hasApproved || canApprove || canMerge || (canChangeStatus && isDraft);
+  const showDraftControl = canChangeStatus && pullRequest.status === "Open";
+
+  if (approvalCount > 0 && !showActions && !showDraftControl) return null;
 
   return (
     <div className="space-y-2.5 pt-3">
-      <PullRequestReviewersRow
-        canRequest={canRequestReview}
-        profiles={profiles}
-        project={project}
-        pullRequest={pullRequest}
-      />
-      <div
-        className={`min-w-0 space-y-2.5 rounded-xl px-3 py-2.5 ${
-          isDraft
-            ? "bg-muted/40"
-            : approvalCount > 0
-              ? "bg-green-600/10 dark:bg-green-500/10"
-              : "bg-muted/40"
-        }`}
-      >
-        <div className="flex min-w-0 items-start gap-2">
-          {isDraft ? (
-            <GitPullRequestDraft className="mt-0.5 h-4 w-4 shrink-0 text-muted-foreground" />
-          ) : approvalCount > 0 ? (
-            <span className="mt-0.5 flex h-5 w-5 shrink-0 items-center justify-center rounded-full bg-green-600 text-white">
-              <Check className="h-3 w-3" />
-            </span>
-          ) : (
-            <GitPullRequest className="mt-0.5 h-4 w-4 shrink-0 text-muted-foreground" />
-          )}
-          <div className="min-w-0 flex-1">
-            <p
-              className={`text-sm font-medium ${
-                approvalCount > 0
-                  ? "text-green-700 dark:text-green-400"
-                  : "text-foreground"
-              }`}
-            >
-              {reviewState}
-            </p>
-            {reviewStateDetail ? (
-              <p className="text-xs text-muted-foreground">
-                {reviewStateDetail}
+      <div className="min-w-0 space-y-2.5 rounded-xl bg-muted/40 px-3 py-2.5">
+        {approvalCount === 0 ? (
+          <div className="flex min-w-0 items-start gap-2">
+            {isDraft ? (
+              <GitPullRequestDraft className="mt-0.5 h-4 w-4 shrink-0 text-muted-foreground" />
+            ) : (
+              <GitPullRequest className="mt-0.5 h-4 w-4 shrink-0 text-muted-foreground" />
+            )}
+            <div className="min-w-0 flex-1">
+              <p className="text-sm font-medium text-foreground">
+                {reviewState}
               </p>
-            ) : null}
+              {reviewStateDetail ? (
+                <p className="text-xs text-muted-foreground">
+                  {reviewStateDetail}
+                </p>
+              ) : null}
+            </div>
           </div>
-        </div>
-        {hasApproved || canApprove || (canChangeStatus && isDraft) ? (
+        ) : null}
+        {showActions ? (
           <div className="flex min-w-0 flex-wrap items-center gap-2">
             {hasApproved ? (
-              <span className="inline-flex items-center gap-1.5 rounded-md border border-green-600/40 px-2.5 py-1 text-xs font-medium text-green-600 dark:text-green-500">
+              <span className="inline-flex h-8 items-center justify-center gap-1.5 rounded-lg border border-green-600/40 px-3.5 text-xs font-medium text-green-600 dark:text-green-500">
                 <Check className="h-3.5 w-3.5" />
                 Approved
               </span>
@@ -522,6 +453,12 @@ function PullRequestReviewCard({
                 Approve
               </Button>
             ) : null}
+            {canMerge ? (
+              <MergePullRequestButton
+                project={project}
+                pullRequest={pullRequest}
+              />
+            ) : null}
             {canChangeStatus && isDraft ? (
               <Button
                 className="h-7 gap-1.5 px-3"
@@ -540,7 +477,7 @@ function PullRequestReviewCard({
           </div>
         ) : null}
       </div>
-      {canChangeStatus && pullRequest.status === "Open" ? (
+      {showDraftControl ? (
         <p className="px-1 text-xs text-muted-foreground">
           Still in progress?{" "}
           <button
@@ -586,8 +523,7 @@ export function PullRequestDetailHeader({
   );
 }
 
-/** Right-hand meta column for the PR detail view: status, author, branches,
- * and dates. Review actions live inline in the conversation column. */
+/** Right-hand meta column for the PR detail view. */
 export function PullRequestMetaRail({
   profiles,
   project,
@@ -597,11 +533,20 @@ export function PullRequestMetaRail({
   project: Project;
   pullRequest: ProjectPullRequest;
 }) {
+  const identityQuery = useIdentityQuery();
   const authorProfile = profileForPubkey(pullRequest.author, profiles);
   const authorLabel = labelForPubkey(pullRequest.author, profiles);
-  const targetBranch = project.defaultBranch || "default branch";
+  const targetBranch =
+    pullRequest.targetBranch || project.defaultBranch || "default branch";
   const sourceBranch = pullRequest.branchName || "unknown branch";
   const commitCount = Math.max(1, pullRequest.updateCount + 1);
+  const viewerPubkey = identityQuery.data?.pubkey;
+  const viewer = viewerPubkey ? normalizePubkey(viewerPubkey) : null;
+  const isAuthor = viewer === normalizePubkey(pullRequest.author);
+  const isOwner = viewer === normalizePubkey(project.owner);
+  const isManagedAgentOwner = useIsManagedAgent(project.owner) === true;
+  const canRequestReview =
+    Boolean(viewer) && (isAuthor || isOwner || isManagedAgentOwner);
 
   return (
     <aside className="min-w-0 space-y-6 border-t border-border/60 p-4 xl:border-l xl:border-t-0">
@@ -617,6 +562,17 @@ export function PullRequestMetaRail({
           {pullRequest.status}
         </span>
       </OverviewRailSection>
+      {pullRequest.reviewers.length > 0 || canRequestReview ? (
+        <OverviewRailSection title="Reviewers">
+          <PullRequestReviewersRow
+            canRequest={canRequestReview}
+            profiles={profiles}
+            project={project}
+            pullRequest={pullRequest}
+            signAsManagedOwner={isManagedAgentOwner && !isOwner}
+          />
+        </OverviewRailSection>
+      ) : null}
       <OverviewRailSection title="Author">
         <ProfileIdentityButton
           align="center"
@@ -704,50 +660,40 @@ function PullRequestDetail({
   );
 
   if (mode === "commits") {
+    const commitCount = Math.max(1, pullRequest.updates.length + 1);
     return (
-      <div className="divide-y divide-border/50">
-        <section className="space-y-3 p-4">
-          <h4 className="text-sm font-semibold text-foreground">Commits</h4>
-          <article className="space-y-1">
-            <div className="flex min-w-0 items-center justify-between gap-3">
-              <AuthorIdentity
-                profiles={profiles}
-                pubkey={pullRequest.author}
-                role={compactDate(pullRequest.createdAt)}
-              />
-              {pullRequest.commit ? (
-                <CommitHashChip
-                  hash={pullRequest.commit}
-                  onOpenCommit={onOpenCommit}
-                />
-              ) : null}
-            </div>
-            <p className="text-sm text-muted-foreground">{pullRequest.title}</p>
-          </article>
+      <section>
+        <header className="flex min-h-10 items-center gap-2 border-b border-border/50 bg-muted/20 px-4">
+          <GitCommitHorizontal className="h-4 w-4 text-muted-foreground" />
+          <h4 className="text-sm font-medium text-foreground">Commits</h4>
+          <span className="rounded-full bg-muted px-1.5 py-0.5 text-2xs text-muted-foreground">
+            {commitCount}
+          </span>
+        </header>
+        <div className="divide-y divide-border/50">
+          <PullRequestCommitRow
+            author={pullRequest.author}
+            branch={pullRequest.branchName}
+            createdAt={pullRequest.createdAt}
+            hash={pullRequest.commit}
+            message={pullRequest.title}
+            onOpenCommit={onOpenCommit}
+            profiles={profiles}
+          />
           {pullRequest.updates.map((update) => (
-            <article className="space-y-1" key={update.id}>
-              <div className="flex min-w-0 items-center justify-between gap-3">
-                <AuthorIdentity
-                  profiles={profiles}
-                  pubkey={update.author}
-                  role={compactDate(update.createdAt)}
-                />
-                {update.commit ? (
-                  <CommitHashChip
-                    hash={update.commit}
-                    onOpenCommit={onOpenCommit}
-                  />
-                ) : null}
-              </div>
-              {update.content ? (
-                <p className="text-sm text-muted-foreground">
-                  {update.content}
-                </p>
-              ) : null}
-            </article>
+            <PullRequestCommitRow
+              author={update.author}
+              branch={pullRequest.branchName}
+              createdAt={update.createdAt}
+              hash={update.commit}
+              key={update.id}
+              message={update.content.trim() || "Updated pull request branch"}
+              onOpenCommit={onOpenCommit}
+              profiles={profiles}
+            />
           ))}
-        </section>
-      </div>
+        </div>
+      </section>
     );
   }
 
@@ -800,19 +746,15 @@ function PullRequestDetail({
       ) : null}
 
       <section className="space-y-3 p-4">
-        <h4 className="flex items-center gap-1.5 text-sm font-semibold text-foreground">
-          <MessageSquare className="h-3.5 w-3.5" />
-          Add Your Comment
-        </h4>
         {pullRequest.comments.length > 0 ? (
-          <div className="space-y-3">
+          <div className="-mt-4">
             {pullRequest.comments.map((item) => {
               // Approvals and review requests render as compact timeline
               // rows (GitHub-style) rather than full comment cards.
               if (item.isApproval || item.isReviewRequest) {
                 return (
                   <div
-                    className="flex min-w-0 flex-wrap items-center gap-1.5 text-xs text-muted-foreground"
+                    className="-mx-4 flex min-h-10 min-w-0 items-center gap-2 border-b border-border/50 px-4 text-sm text-muted-foreground"
                     key={item.id}
                   >
                     {item.isApproval ? (
@@ -820,20 +762,24 @@ function PullRequestDetail({
                     ) : (
                       <UserPlus className="h-3.5 w-3.5 shrink-0" />
                     )}
-                    <span className="font-medium text-foreground">
-                      {labelForPubkey(item.author, profiles)}
+                    <span className="flex min-w-0 flex-1 items-center gap-1.5 overflow-hidden">
+                      <span className="shrink-0 font-medium text-foreground">
+                        {labelForPubkey(item.author, profiles)}
+                      </span>
+                      <span className="min-w-0 truncate">
+                        {item.isApproval
+                          ? "approved these changes"
+                          : item.content.trim() || "requested a review"}
+                      </span>
                     </span>
-                    <span className="min-w-0 truncate">
-                      {item.isApproval
-                        ? "approved these changes"
-                        : item.content.trim() || "requested a review"}
+                    <span className="w-20 shrink-0 text-right text-xs text-muted-foreground/70">
+                      {compactDate(item.createdAt)}
                     </span>
-                    <span>· {compactDate(item.createdAt)}</span>
                   </div>
                 );
               }
               return (
-                <article key={item.id}>
+                <article className="py-3" key={item.id}>
                   <div className="mb-2">
                     <AuthorIdentity
                       profiles={profiles}
@@ -850,14 +796,12 @@ function PullRequestDetail({
               );
             })}
           </div>
-        ) : (
-          <p className="text-sm text-muted-foreground">No comments yet.</p>
-        )}
-        <PullRequestReviewCard
-          profiles={profiles}
-          project={project}
-          pullRequest={pullRequest}
-        />
+        ) : null}
+        <PullRequestReviewCard project={project} pullRequest={pullRequest} />
+        <h4 className="flex items-center gap-1.5 text-sm font-semibold text-foreground">
+          <MessageSquare className="h-3.5 w-3.5" />
+          Add Your Comment
+        </h4>
         <ForumComposer
           className="border border-border/60 bg-background/45"
           disabled={commentMutation.isPending}
diff --git a/desktop/src/features/projects/ui/ProjectReadmePanel.tsx b/desktop/src/features/projects/ui/ProjectReadmePanel.tsx
index 0dec87c2cb..0a599348bb 100644
--- a/desktop/src/features/projects/ui/ProjectReadmePanel.tsx
+++ b/desktop/src/features/projects/ui/ProjectReadmePanel.tsx
@@ -89,7 +89,7 @@ export function ReadmePanel({
   const header = (
     <>
       {sourceControls ? (
-        <div className="flex min-h-10 min-w-0 items-center gap-1 border-border/50 border-b px-3 py-1.5">
+        <div className="flex min-h-14 min-w-0 items-center gap-1 border-border/50 border-b px-3 py-3">
           <RepoSourceDropdown controls={sourceControls} />
           <RepositoryBranchDropdown
             branch={sourceControls.branch}
diff --git a/desktop/src/features/projects/ui/ProjectRepositoryPanel.tsx b/desktop/src/features/projects/ui/ProjectRepositoryPanel.tsx
index 83d423d801..575fdc268b 100644
--- a/desktop/src/features/projects/ui/ProjectRepositoryPanel.tsx
+++ b/desktop/src/features/projects/ui/ProjectRepositoryPanel.tsx
@@ -575,7 +575,7 @@ function FileContentPanel({
 
   return (
     <div className="overflow-hidden rounded-xl border border-border/60 bg-card">
-      <div className="flex min-h-10 items-center gap-1 border-border/50 border-b bg-muted/20 px-3">
+      <div className="flex min-h-14 items-center gap-1 border-border/50 border-b bg-muted/20 px-3 py-3">
         <BreadcrumbButton onClick={() => onOpenPath("")}>
           Files
         </BreadcrumbButton>
@@ -718,7 +718,7 @@ export function RepositoryFilesPanel({
     }
     return (
       <div className="overflow-hidden rounded-xl border border-border/60 bg-card">
-        <div className="flex min-h-10 min-w-0 items-center gap-1 border-border/50 border-b px-3 py-1.5">
+        <div className="flex min-h-14 min-w-0 items-center gap-1 border-border/50 border-b px-3 py-3">
           <RepoSourceDropdown controls={sourceControls} />
           <RepositoryBranchDropdown
             branch={sourceControls.branch}
@@ -749,7 +749,7 @@ export function RepositoryFilesPanel({
 
   return (
     <div className="overflow-hidden rounded-xl border border-border/60 bg-card">
-      <div className="flex min-h-10 min-w-0 items-center gap-1 border-border/50 border-b px-3 py-1.5">
+      <div className="flex min-h-14 min-w-0 items-center gap-1 border-border/50 border-b px-3 py-3">
         {sourceControls ? (
           <>
             <RepoSourceDropdown controls={sourceControls} />
diff --git a/desktop/src/features/projects/ui/ProjectRepositorySource.tsx b/desktop/src/features/projects/ui/ProjectRepositorySource.tsx
index c6b8fbea52..e627da9b04 100644
--- a/desktop/src/features/projects/ui/ProjectRepositorySource.tsx
+++ b/desktop/src/features/projects/ui/ProjectRepositorySource.tsx
@@ -17,6 +17,7 @@ import {
   DropdownMenuRadioItem,
   DropdownMenuTrigger,
 } from "@/shared/ui/dropdown-menu";
+import { PROJECT_PANEL_ACTION_BUTTON_CLASS } from "./projectPanelStyles";
 
 /** Branch picker shared by the readme and files panel headers. */
 export function RepositoryBranchDropdown({
@@ -46,14 +47,14 @@ export function RepositoryBranchDropdown({
         <Button
           className={
             compact
-              ? "h-6 max-w-full gap-1 px-1.5 font-mono text-xs font-medium"
+              ? "h-7 max-w-full gap-1.5 rounded-md bg-muted px-3 font-mono text-sm font-medium hover:bg-muted/80"
               : "h-6 max-w-full gap-1.5 px-2 font-mono text-sm font-semibold"
           }
           size="sm"
           type="button"
           variant="ghost"
         >
-          <GitBranch className="h-3 w-3 shrink-0 text-muted-foreground" />
+          <GitBranch className="h-4 w-4 shrink-0 text-muted-foreground" />
           <span className="truncate">{branch}</span>
           <ChevronDown className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
         </Button>
@@ -114,12 +115,12 @@ export function RepoSourceDropdown({
     <DropdownMenu>
       <DropdownMenuTrigger asChild>
         <Button
-          className="h-6 max-w-full shrink-0 gap-1 px-1.5 text-xs font-medium"
+          className="h-7 max-w-full shrink-0 gap-1.5 rounded-md bg-muted px-3 text-sm font-medium hover:bg-muted/80"
           size="sm"
           type="button"
           variant="ghost"
         >
-          <SourceIcon className="h-3 w-3 shrink-0 text-muted-foreground" />
+          <SourceIcon className="h-4 w-4 shrink-0 text-muted-foreground" />
           <span className="truncate">
             {isLocal ? controls.localLabel : controls.remoteLabel}
           </span>
@@ -164,7 +165,7 @@ export function RepoSyncActionButton({
     const count = controls.behindCount ?? 0;
     return (
       <Button
-        className="h-6 shrink-0 gap-1 rounded-full px-2.5 text-xs"
+        className={PROJECT_PANEL_ACTION_BUTTON_CLASS}
         disabled={controls.pullDisabled}
         onClick={controls.onPull}
         size="sm"
@@ -172,9 +173,9 @@ export function RepoSyncActionButton({
         variant="ghost"
       >
         {controls.pullPending ? (
-          <Loader2 className="h-3 w-3 animate-spin" />
+          <Loader2 className="h-4 w-4 animate-spin" />
         ) : (
-          <DownloadCloud className="h-3 w-3" />
+          <DownloadCloud className="h-4 w-4" />
         )}
         Pull{count > 0 ? ` ${count}` : ""}
       </Button>
@@ -182,10 +183,9 @@ export function RepoSyncActionButton({
   }
 
   if (push) {
-    const count = controls.aheadCount ?? 0;
     return (
       <Button
-        className="h-6 shrink-0 gap-1 rounded-full px-2.5 text-xs"
+        className={PROJECT_PANEL_ACTION_BUTTON_CLASS}
         disabled={controls.pushDisabled}
         onClick={controls.onPush}
         size="sm"
@@ -193,11 +193,11 @@ export function RepoSyncActionButton({
         variant="ghost"
       >
         {controls.pushPending ? (
-          <Loader2 className="h-3 w-3 animate-spin" />
+          <Loader2 className="h-4 w-4 animate-spin" />
         ) : (
-          <UploadCloud className="h-3 w-3" />
+          <UploadCloud className="h-4 w-4" />
         )}
-        Push{count > 0 ? ` ${count}` : ""}
+        Push
       </Button>
     );
   }
@@ -205,7 +205,7 @@ export function RepoSyncActionButton({
   if (!controls.onFetch) return null;
   return (
     <Button
-      className="h-6 shrink-0 gap-1 rounded-full px-2.5 text-xs"
+      className={PROJECT_PANEL_ACTION_BUTTON_CLASS}
       disabled={controls.fetchPending}
       onClick={controls.onFetch}
       size="sm"
@@ -213,9 +213,9 @@ export function RepoSyncActionButton({
       variant="ghost"
     >
       {controls.fetchPending ? (
-        <Loader2 className="h-3 w-3 animate-spin" />
+        <Loader2 className="h-4 w-4 animate-spin" />
       ) : (
-        <RefreshCw className="h-3 w-3" />
+        <RefreshCw className="h-4 w-4" />
       )}
       Fetch
     </Button>
diff --git a/desktop/src/features/projects/ui/ProjectWorkspaceTabList.tsx b/desktop/src/features/projects/ui/ProjectWorkspaceTabList.tsx
index 67aaf35578..e8eca37dec 100644
--- a/desktop/src/features/projects/ui/ProjectWorkspaceTabList.tsx
+++ b/desktop/src/features/projects/ui/ProjectWorkspaceTabList.tsx
@@ -1,48 +1,63 @@
 import { BookOpen } from "lucide-react";
 
 import type { ProjectPullRequest } from "@/features/projects/hooks";
+import { cn } from "@/shared/lib/cn";
 import { TabsList, TabsTrigger } from "@/shared/ui/tabs";
 
-const PROJECT_TAB_TRIGGER_BASE_CLASS =
-  "rounded-full text-foreground hover:bg-accent hover:text-accent-foreground data-[state=active]:bg-sidebar-active data-[state=active]:text-sidebar-active-foreground data-[state=active]:shadow-xs data-[state=active]:hover:bg-sidebar-active data-[state=active]:hover:text-sidebar-active-foreground";
-
-const PROJECT_TAB_TRIGGER_CLASS = `${PROJECT_TAB_TRIGGER_BASE_CLASS} h-8 gap-1.5 px-3 text-xs xl:px-3.5 xl:text-sm`;
-
-const PROJECT_ICON_TAB_TRIGGER_CLASS = `${PROJECT_TAB_TRIGGER_BASE_CLASS} h-8 w-8 shrink-0 border border-border/60 p-2 data-[state=active]:border-transparent`;
+const PROJECT_TAB_TRIGGER_CLASS =
+  "relative h-full shrink-0 rounded-none px-2.5 text-base leading-5 tracking-tight text-muted-foreground shadow-none after:absolute after:inset-x-2.5 after:bottom-0 after:h-0.5 after:bg-current after:opacity-0 after:transition-opacity after:content-[''] hover:bg-transparent hover:font-semibold hover:text-foreground hover:after:opacity-100 data-[state=active]:bg-transparent data-[state=active]:font-semibold data-[state=active]:text-foreground data-[state=active]:shadow-none data-[state=active]:after:opacity-100";
 
 const PROJECT_TAB_SELECTED_CLASS =
-  " bg-sidebar-active text-sidebar-active-foreground shadow-xs hover:bg-sidebar-active hover:text-sidebar-active-foreground";
+  "font-semibold text-foreground after:opacity-100";
+const PROJECT_OVERVIEW_TAB_CLASS =
+  "h-8 w-8 shrink-0 rounded-md p-2 text-muted-foreground shadow-none hover:bg-muted/50 hover:text-foreground data-[state=active]:bg-muted/50 data-[state=active]:text-foreground data-[state=active]:shadow-none";
+
+function ProjectTabLabel({ children }: { children: string }) {
+  return (
+    <span className="grid">
+      <span
+        aria-hidden="true"
+        className="invisible col-start-1 row-start-1 font-semibold"
+      >
+        {children}
+      </span>
+      <span className="col-start-1 row-start-1">{children}</span>
+    </span>
+  );
+}
 
 export function ProjectTabsList({ prsActive }: { prsActive?: boolean }) {
   return (
-    <TabsList className="h-9 w-fit justify-start gap-1 bg-transparent p-0">
+    <TabsList className="h-full min-w-0 max-w-full flex-none justify-start gap-1 overflow-x-auto bg-transparent p-0 scrollbar-none">
       <TabsTrigger
         aria-label="Overview"
-        className={PROJECT_ICON_TAB_TRIGGER_CLASS}
-        title="Overview"
+        className={PROJECT_OVERVIEW_TAB_CLASS}
+        title="README"
         value="overview"
       >
         <BookOpen className="h-full w-full" strokeWidth={2} />
       </TabsTrigger>
       <TabsTrigger className={PROJECT_TAB_TRIGGER_CLASS} value="files">
-        Code
+        <ProjectTabLabel>Files</ProjectTabLabel>
       </TabsTrigger>
       <TabsTrigger className={PROJECT_TAB_TRIGGER_CLASS} value="activity">
-        Commits
+        <ProjectTabLabel>Commits</ProjectTabLabel>
       </TabsTrigger>
       <TabsTrigger className={PROJECT_TAB_TRIGGER_CLASS} value="issues">
-        Issues
+        <ProjectTabLabel>Issues</ProjectTabLabel>
       </TabsTrigger>
       <TabsTrigger
-        className={`${PROJECT_TAB_TRIGGER_CLASS}${
-          prsActive ? PROJECT_TAB_SELECTED_CLASS : ""
-        }`}
+        aria-current={prsActive ? "page" : undefined}
+        className={cn(
+          PROJECT_TAB_TRIGGER_CLASS,
+          prsActive && PROJECT_TAB_SELECTED_CLASS,
+        )}
         value="prs"
       >
-        PRs
+        <ProjectTabLabel>Pull Request</ProjectTabLabel>
       </TabsTrigger>
       <TabsTrigger className={PROJECT_TAB_TRIGGER_CLASS} value="contributors">
-        Contributors
+        <ProjectTabLabel>Contributors</ProjectTabLabel>
       </TabsTrigger>
     </TabsList>
   );
diff --git a/desktop/src/features/projects/ui/ProjectWorkspaceTabs.tsx b/desktop/src/features/projects/ui/ProjectWorkspaceTabs.tsx
index e2707faf69..3a0e960b2f 100644
--- a/desktop/src/features/projects/ui/ProjectWorkspaceTabs.tsx
+++ b/desktop/src/features/projects/ui/ProjectWorkspaceTabs.tsx
@@ -1,5 +1,13 @@
-import { SquareTerminal } from "lucide-react";
+import {
+  CircleDot,
+  Download,
+  GitPullRequest,
+  Plus,
+  RefreshCw,
+  SquareTerminal,
+} from "lucide-react";
 import * as React from "react";
+import type { ComponentType } from "react";
 
 import type {
   Project,
@@ -33,11 +41,78 @@ import {
   PullRequestTabsList,
 } from "./ProjectWorkspaceTabList";
 import { ProjectPullRequestFilesChangedPanel } from "./ProjectPullRequestFilesChangedPanel";
+import { CreatePullRequestDialog } from "./CreatePullRequestDialog";
+import {
+  CreateIssueDialog,
+  type CreateIssueDialogInput,
+} from "./CreateIssueDialog";
+import { PROJECT_PANEL_ACTION_BUTTON_CLASS } from "./projectPanelStyles";
+
+type CloneRepositoryAction = {
+  onClone: () => void;
+  pending: boolean;
+};
+
+type CreatePullRequestAction = {
+  projects: Project[];
+  reposDir?: string | null;
+  onCreated: (project: Project, pullRequestId: string) => void | Promise<void>;
+};
+
+type CreateIssueAction = {
+  onCreate: (input: CreateIssueDialogInput) => Promise<void>;
+  pending: boolean;
+};
+
+type UpdatePullRequestAction = {
+  onUpdate: () => void;
+  pending: boolean;
+};
+
+function WorkItemListHeader({
+  actionDisabled = false,
+  actionLabel,
+  actionTitle,
+  icon: Icon,
+  onAction,
+  title,
+}: {
+  actionDisabled?: boolean;
+  actionLabel: string;
+  actionTitle?: string;
+  icon: ComponentType<{ className?: string }>;
+  onAction: () => void;
+  title: string;
+}) {
+  return (
+    <div className="flex min-h-14 items-center gap-2 border-border/50 border-b px-4 py-3">
+      <Icon className="h-4 w-4 text-muted-foreground" />
+      <span className="min-w-0 flex-1 truncate text-sm font-medium text-foreground">
+        {title}
+      </span>
+      <Button
+        className={PROJECT_PANEL_ACTION_BUTTON_CLASS}
+        disabled={actionDisabled}
+        onClick={onAction}
+        size="xs"
+        title={actionTitle}
+        variant="ghost"
+      >
+        <Plus className="h-4 w-4" />
+        {actionLabel}
+      </Button>
+    </div>
+  );
+}
 
 export function WorkspaceTabs({
+  cloneAction,
   commitDiff,
   commitDiffError,
   commitDiffLoading,
+  createIssueAction,
+  createPullRequestAction,
+  updatePullRequestAction,
   localSnapshot,
   localSnapshotError,
   localSnapshotLoading,
@@ -67,9 +142,13 @@ export function WorkspaceTabs({
   terminalTitle,
   viewerGitIdentity,
 }: {
+  cloneAction?: CloneRepositoryAction;
   commitDiff: ProjectRepoDiff | null | undefined;
   commitDiffError: unknown;
   commitDiffLoading: boolean;
+  createIssueAction: CreateIssueAction;
+  createPullRequestAction?: CreatePullRequestAction;
+  updatePullRequestAction?: UpdatePullRequestAction;
   localSnapshot: ProjectLocalRepoSnapshot | null | undefined;
   localSnapshotError: unknown;
   localSnapshotLoading: boolean;
@@ -122,6 +201,9 @@ export function WorkspaceTabs({
     ) ?? null;
   const isPullRequestSelected = Boolean(selectedPullRequest);
   const [selectedTab, setSelectedTab] = React.useState("overview");
+  const [createIssueOpen, setCreateIssueOpen] = React.useState(false);
+  const [createPullRequestOpen, setCreatePullRequestOpen] =
+    React.useState(false);
 
   React.useEffect(() => {
     onSelectedTabChange?.(selectedTab);
@@ -180,7 +262,7 @@ export function WorkspaceTabs({
       onValueChange={handleTabChange}
       value={selectedTab}
     >
-      <div className="flex min-w-0 items-center gap-1">
+      <div className="flex h-10 min-w-0 items-center gap-1">
         <ProjectTabsList prsActive={isPullRequestSelected} />
         {onOpenTerminal ? (
           <Button
@@ -194,8 +276,33 @@ export function WorkspaceTabs({
             <SquareTerminal className="h-[1.125rem] w-[1.125rem]" />
           </Button>
         ) : null}
+        {cloneAction ? (
+          <Button
+            className="h-8 shrink-0 gap-1.5"
+            disabled={cloneAction.pending}
+            onClick={cloneAction.onClone}
+            size="sm"
+            title="Clone repository"
+            variant="outline"
+          >
+            <Download className="h-4 w-4" />
+            {cloneAction.pending ? "Cloning…" : "Clone"}
+          </Button>
+        ) : null}
+        {updatePullRequestAction ? (
+          <Button
+            className="h-8 shrink-0 gap-1.5"
+            disabled={updatePullRequestAction.pending}
+            onClick={updatePullRequestAction.onUpdate}
+            size="sm"
+            title="Publish the pushed commit to this pull request"
+            variant="outline"
+          >
+            <RefreshCw className="h-4 w-4" />
+            {updatePullRequestAction.pending ? "Updating…" : "Update PR"}
+          </Button>
+        ) : null}
       </div>
-
       {selectedPullRequest ? (
         <div className="overflow-hidden rounded-xl border border-border/60 bg-card">
           {/* Two full-height columns: the meta rail runs all the way to the
@@ -279,6 +386,7 @@ export function WorkspaceTabs({
           />
         ) : (
           <ActivityPanel
+            branch={sourceControls?.branch}
             error={displayedSnapshotError}
             isLoading={displayedSnapshotLoading}
             onSelectCommit={(commit) => onSelectedCommitHashChange(commit.hash)}
@@ -295,6 +403,17 @@ export function WorkspaceTabs({
         className="m-0 overflow-hidden rounded-xl border border-border/60 bg-card"
         value="prs"
       >
+        <WorkItemListHeader
+          actionDisabled={
+            !createPullRequestAction ||
+            createPullRequestAction.projects.length === 0
+          }
+          actionLabel="Pull Request"
+          actionTitle="Choose a repository and branches to compare."
+          icon={GitPullRequest}
+          onAction={() => setCreatePullRequestOpen(true)}
+          title="Pull Requests"
+        />
         <PullRequestsPanel
           error={pullRequestsError}
           isLoading={pullRequestsLoading}
@@ -311,6 +430,13 @@ export function WorkspaceTabs({
         className="m-0 overflow-hidden rounded-xl border border-border/60 bg-card"
         value="issues"
       >
+        <WorkItemListHeader
+          actionDisabled={createIssueAction.pending}
+          actionLabel="Issues"
+          icon={CircleDot}
+          onAction={() => setCreateIssueOpen(true)}
+          title="Issues"
+        />
         <ProjectIssuesPanel
           onSelectedIssueIdChange={onSelectedIssueIdChange}
           profiles={profiles}
@@ -344,6 +470,23 @@ export function WorkspaceTabs({
           repoContributors={displayedContributors}
         />
       </TabsContent>
+      {createPullRequestAction && createPullRequestOpen ? (
+        <CreatePullRequestDialog
+          initialProjectId={project.id}
+          onCreated={createPullRequestAction.onCreated}
+          onOpenChange={setCreatePullRequestOpen}
+          open
+          projects={createPullRequestAction.projects}
+          reposDir={createPullRequestAction.reposDir}
+        />
+      ) : null}
+      <CreateIssueDialog
+        isCreating={createIssueAction.pending}
+        onCreate={createIssueAction.onCreate}
+        onOpenChange={setCreateIssueOpen}
+        open={createIssueOpen}
+        projectName={project.name}
+      />
     </Tabs>
   );
 }
diff --git a/desktop/src/features/projects/ui/ProjectsActivityFeed.tsx b/desktop/src/features/projects/ui/ProjectsActivityFeed.tsx
index 5802922432..70dc560d01 100644
--- a/desktop/src/features/projects/ui/ProjectsActivityFeed.tsx
+++ b/desktop/src/features/projects/ui/ProjectsActivityFeed.tsx
@@ -1,14 +1,3 @@
-import {
-  Check,
-  CircleDot,
-  FolderGit2,
-  GitCommitHorizontal,
-  GitPullRequest,
-  MessageSquare,
-  UserPlus,
-} from "lucide-react";
-import type { ComponentType } from "react";
-
 import {
   resolveUserLabel,
   type UserProfileLookup,
@@ -31,15 +20,12 @@ import { cn } from "@/shared/lib/cn";
 import { normalizePubkey } from "@/shared/lib/pubkey";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
+import {
+  PROJECT_EVENT_VISUALS,
+  type ProjectEventKind,
+} from "./ProjectEventTypeIcon";
 
-type ActivityKind =
-  | "repository"
-  | "commit"
-  | "pull-request"
-  | "issue"
-  | "comment"
-  | "approval"
-  | "review-request";
+type ActivityKind = ProjectEventKind;
 
 type ActivityTarget =
   | { type: "project"; project: Project }
@@ -83,66 +69,6 @@ type ProjectsActivityFeedProps = {
 
 const ACTIVITY_LIMIT = 30;
 
-const KIND_VISUALS: Record<
-  ActivityKind,
-  {
-    icon: ComponentType<{ className?: string }>;
-    iconClassName: string;
-    badgeClassName: string;
-    detailClassName: string;
-  }
-> = {
-  repository: {
-    icon: FolderGit2,
-    iconClassName: "text-primary",
-    badgeClassName: "bg-primary/10 text-primary",
-    detailClassName: "border-primary/30 text-primary",
-  },
-  commit: {
-    icon: GitCommitHorizontal,
-    iconClassName: "text-primary",
-    badgeClassName: "bg-primary/10 text-primary",
-    detailClassName: "border-primary/30 text-primary",
-  },
-  "pull-request": {
-    icon: GitPullRequest,
-    iconClassName: "text-green-600 dark:text-green-500",
-    badgeClassName:
-      "bg-green-600/10 text-green-700 dark:bg-green-500/10 dark:text-green-400",
-    detailClassName:
-      "border-green-600/30 text-green-700 dark:border-green-500/30 dark:text-green-400",
-  },
-  issue: {
-    icon: CircleDot,
-    iconClassName: "text-orange-500",
-    badgeClassName: "bg-orange-500/10 text-orange-700 dark:text-orange-300",
-    detailClassName:
-      "border-orange-500/30 text-orange-700 dark:text-orange-300",
-  },
-  comment: {
-    icon: MessageSquare,
-    iconClassName: "text-muted-foreground",
-    badgeClassName: "bg-muted text-muted-foreground",
-    detailClassName: "border-border/60 text-muted-foreground",
-  },
-  approval: {
-    icon: Check,
-    iconClassName: "text-green-600 dark:text-green-500",
-    badgeClassName:
-      "bg-green-600/10 text-green-700 dark:bg-green-500/10 dark:text-green-400",
-    detailClassName:
-      "border-green-600/30 text-green-700 dark:border-green-500/30 dark:text-green-400",
-  },
-  "review-request": {
-    icon: UserPlus,
-    iconClassName: "text-blue-600 dark:text-blue-400",
-    badgeClassName:
-      "bg-blue-600/10 text-blue-700 dark:bg-blue-500/10 dark:text-blue-300",
-    detailClassName:
-      "border-blue-600/30 text-blue-700 dark:border-blue-500/30 dark:text-blue-300",
-  },
-};
-
 function contentPreview(content: string) {
   return markdownToPlainText(content).replace(/\s+/g, " ").trim().slice(0, 280);
 }
@@ -300,7 +226,7 @@ function ActivityCard({
   onOpenProject: () => void;
   profiles?: UserProfileLookup;
 }) {
-  const visual = KIND_VISUALS[item.kind];
+  const visual = PROJECT_EVENT_VISUALS[item.kind];
   const profile = item.actorPubkey
     ? profiles?.[normalizePubkey(item.actorPubkey)]
     : undefined;
@@ -401,7 +327,7 @@ function ActivityCard({
             ) : null}
           </div>
           <div className={compact ? "mt-2" : "mt-3"}>
-            <p className="min-w-0 truncate text-sm font-semibold text-foreground">
+            <p className="min-w-0 truncate text-sm font-semibold leading-5 text-foreground">
               {item.title}
             </p>
             {item.body ? (
@@ -458,32 +384,9 @@ export function ProjectsActivityFeed(props: ProjectsActivityFeedProps) {
     <div
       className={cn("relative", props.compact ? "space-y-2.5" : "space-y-3")}
     >
-      <div
-        aria-hidden="true"
-        className="absolute bottom-2 left-[7px] top-2 w-px bg-border/45"
-      />
       {items.map((item) => {
-        const visual = KIND_VISUALS[item.kind];
-        const Icon = visual.icon;
         return (
-          <div className="relative pl-7" key={item.id}>
-            <span
-              aria-hidden="true"
-              className={cn(
-                "absolute left-2 h-px w-5 bg-border/60",
-                props.compact ? "top-[1.375rem]" : "top-[2.125rem]",
-              )}
-            />
-            <span
-              aria-hidden="true"
-              className={cn(
-                "absolute left-0 z-10 flex h-4 w-4 items-center justify-center rounded-full ring-1 ring-border/60",
-                props.compact ? "top-3.5" : "top-[1.625rem]",
-                visual.badgeClassName,
-              )}
-            >
-              <Icon className={cn("h-3 w-3", visual.iconClassName)} />
-            </span>
+          <div className="relative" key={item.id}>
             <ActivityCard
               compact={props.compact === true}
               item={item}
diff --git a/desktop/src/features/projects/ui/ProjectsContributionGraph.tsx b/desktop/src/features/projects/ui/ProjectsContributionGraph.tsx
index a76ace6dc5..64d3430fe6 100644
--- a/desktop/src/features/projects/ui/ProjectsContributionGraph.tsx
+++ b/desktop/src/features/projects/ui/ProjectsContributionGraph.tsx
@@ -55,14 +55,14 @@ function levelFor(count: number) {
 }
 
 /** Week columns (each 7 days, Sunday first) ending with the current week. */
-function buildWeeks(today: Date) {
+function buildWeeks(today: Date, weekCount: number) {
   const start = new Date(
     today.getFullYear(),
     today.getMonth(),
-    today.getDate() - today.getDay() - (WEEK_COUNT - 1) * DAYS_PER_WEEK,
+    today.getDate() - today.getDay() - (weekCount - 1) * DAYS_PER_WEEK,
   );
 
-  return Array.from({ length: WEEK_COUNT }, (_, weekIndex) =>
+  return Array.from({ length: weekCount }, (_, weekIndex) =>
     Array.from({ length: DAYS_PER_WEEK }, (_, dayIndex) => {
       const date = new Date(start);
       date.setDate(start.getDate() + weekIndex * DAYS_PER_WEEK + dayIndex);
@@ -92,19 +92,24 @@ function monthLabels(weeks: Date[][]) {
 export function ProjectsContributionGraph({
   activityByDay,
   className,
+  compact = false,
 }: {
   activityByDay: Record<string, number>;
   className?: string;
+  compact?: boolean;
 }) {
   const today = new Date();
-  const weeks = buildWeeks(today);
+  const weeks = buildWeeks(today, compact ? 18 : WEEK_COUNT);
   const labels = monthLabels(weeks);
   const gridTemplateColumns = `repeat(${weeks.length}, minmax(0, 1fr))`;
   const todayKey = dayKeyOf(today);
 
   return (
     <div className={cn("space-y-2", className)}>
-      <div className="grid gap-2" style={{ gridTemplateColumns }}>
+      <div
+        className={cn("grid", compact ? "gap-1" : "gap-2")}
+        style={{ gridTemplateColumns }}
+      >
         {labels.map((label, index) => (
           <span
             className="overflow-visible whitespace-nowrap text-2xs font-medium text-muted-foreground"
@@ -117,7 +122,10 @@ export function ProjectsContributionGraph({
         ))}
       </div>
       <div
-        className="grid grid-flow-col grid-rows-7 gap-2"
+        className={cn(
+          "grid grid-flow-col grid-rows-7",
+          compact ? "gap-1" : "gap-2",
+        )}
         style={{ gridTemplateColumns }}
       >
         {weeks.map((week) =>
diff --git a/desktop/src/features/projects/ui/ProjectsCreateMenu.tsx b/desktop/src/features/projects/ui/ProjectsCreateMenu.tsx
new file mode 100644
index 0000000000..4550682c2e
--- /dev/null
+++ b/desktop/src/features/projects/ui/ProjectsCreateMenu.tsx
@@ -0,0 +1,121 @@
+import { CircleDot, FolderGit2, GitPullRequest, Plus } from "lucide-react";
+import * as React from "react";
+
+import { Button } from "@/shared/ui/button";
+import {
+  POPOVER_SHADOW_STYLE,
+  POPOVER_SURFACE_CLASS,
+} from "@/shared/ui/popoverSurface";
+
+const MENU_ITEM_CLASS =
+  "flex min-h-9 w-full items-center gap-2 rounded-lg py-2 pl-2 pr-4 text-left text-sm outline-hidden transition-colors hover:bg-muted/50 focus:bg-muted/50 focus:text-foreground focus-visible:ring-1 focus-visible:ring-ring [&_svg]:size-4 [&_svg]:shrink-0";
+
+export function ProjectsCreateMenu({
+  onCreateIssue,
+  onCreatePullRequest,
+  onCreateRepository,
+}: {
+  onCreateIssue: () => void;
+  onCreatePullRequest: () => void;
+  onCreateRepository: () => void;
+}) {
+  const [open, setOpen] = React.useState(false);
+  const containerRef = React.useRef<HTMLElement>(null);
+
+  React.useEffect(() => {
+    if (!open) return;
+    function handlePointerDown(event: PointerEvent) {
+      if (!containerRef.current?.contains(event.target as Node)) {
+        setOpen(false);
+      }
+    }
+    globalThis.document.addEventListener(
+      "pointerdown",
+      handlePointerDown,
+      true,
+    );
+    return () =>
+      globalThis.document.removeEventListener(
+        "pointerdown",
+        handlePointerDown,
+        true,
+      );
+  }, [open]);
+
+  function select(action: () => void) {
+    setOpen(false);
+    action();
+  }
+
+  return (
+    <nav
+      aria-label="Create project item"
+      className="relative shrink-0 pl-4"
+      onBlurCapture={(event) => {
+        if (!event.currentTarget.contains(event.relatedTarget)) {
+          setOpen(false);
+        }
+      }}
+      onKeyDown={(event) => {
+        if (event.key === "Escape") {
+          setOpen(false);
+          containerRef.current?.querySelector<HTMLElement>("button")?.focus();
+        }
+      }}
+      onMouseEnter={() => setOpen(true)}
+      onMouseLeave={() => setOpen(false)}
+      ref={containerRef}
+    >
+      <Button
+        aria-expanded={open}
+        aria-haspopup="menu"
+        aria-label="Create"
+        className="h-8 w-8 rounded-full"
+        data-testid="projects-create-menu"
+        onClick={() => setOpen(true)}
+        size="icon"
+        type="button"
+        variant="default"
+      >
+        <Plus className="h-4 w-4" />
+      </Button>
+      {open ? (
+        <div className="absolute right-0 top-full z-50 min-w-48 pt-1">
+          <div
+            className={`rounded-xl p-1 ${POPOVER_SURFACE_CLASS}`}
+            role="menu"
+            style={POPOVER_SHADOW_STYLE}
+          >
+            <button
+              className={MENU_ITEM_CLASS}
+              onClick={() => select(onCreateRepository)}
+              role="menuitem"
+              type="button"
+            >
+              <FolderGit2 />
+              Repository
+            </button>
+            <button
+              className={MENU_ITEM_CLASS}
+              onClick={() => select(onCreateIssue)}
+              role="menuitem"
+              type="button"
+            >
+              <CircleDot />
+              Issue
+            </button>
+            <button
+              className={MENU_ITEM_CLASS}
+              onClick={() => select(onCreatePullRequest)}
+              role="menuitem"
+              type="button"
+            >
+              <GitPullRequest />
+              Pull Request
+            </button>
+          </div>
+        </div>
+      ) : null}
+    </nav>
+  );
+}
diff --git a/desktop/src/features/projects/ui/ProjectsIssuesList.tsx b/desktop/src/features/projects/ui/ProjectsIssuesList.tsx
index a82376de0b..00dd20a811 100644
--- a/desktop/src/features/projects/ui/ProjectsIssuesList.tsx
+++ b/desktop/src/features/projects/ui/ProjectsIssuesList.tsx
@@ -1,4 +1,4 @@
-import { CircleCheck, CircleDot, CircleX, MessageSquare } from "lucide-react";
+import { Eye, MessageSquare } from "lucide-react";
 
 import type {
   Project,
@@ -12,6 +12,19 @@ import {
 import { UserProfilePopover } from "@/features/profile/ui/UserProfilePopover";
 import { Button } from "@/shared/ui/button";
 import { Card } from "@/shared/ui/card";
+import { DropdownMenuItem } from "@/shared/ui/dropdown-menu";
+import { ProjectEventTypeIcon } from "./ProjectEventTypeIcon";
+import { ProjectListRowMenu } from "./ProjectListRowMenu";
+import {
+  PROJECT_LIST_CONTAINER_CLASS,
+  PROJECT_LIST_ROW_CLASS,
+  PROJECT_LIST_ROW_CONTENT_CLASS,
+  PROJECT_LIST_ROW_DATE_CLASS,
+  PROJECT_LIST_ROW_STATUS_CLASS,
+  PROJECT_LIST_ROW_SUBTEXT_CLASS,
+  PROJECT_LIST_ROW_TITLE_CLASS,
+  PROJECT_LIST_ROW_TRAILING_CLASS,
+} from "./projectListRowStyles";
 
 type ProjectsIssuesListProps = {
   isLoading: boolean;
@@ -40,16 +53,6 @@ function formatRelativeTime(createdAt: number) {
   return `${value} ${unit.label}${value === 1 ? "" : "s"} ago`;
 }
 
-function issueStatusVisual(status: ProjectIssue["status"]) {
-  if (status === "Done") {
-    return { className: "text-purple-400", icon: CircleCheck };
-  }
-  if (status === "Closed") {
-    return { className: "text-destructive", icon: CircleX };
-  }
-  return { className: "text-green-500", icon: CircleDot };
-}
-
 function nextStepLabel(status: ProjectIssue["status"]) {
   if (status === "Done" || status === "Closed") return "View issue";
   if (status === "In Review") return "Review issue";
@@ -58,27 +61,29 @@ function nextStepLabel(status: ProjectIssue["status"]) {
 }
 
 function IssueHeader({
+  includeDate = true,
   issue,
   profiles,
   project,
 }: {
+  includeDate?: boolean;
   issue: ProjectIssue;
   profiles?: UserProfileLookup;
   project: Project;
 }) {
   const authorLabel = resolveUserLabel({ profiles, pubkey: issue.author });
-  const status = issueStatusVisual(issue.status);
 
   return (
-    <div className="min-w-0 flex-1 space-y-1">
+    <div className="-mt-0.5 min-w-0 flex-1">
       <div className="flex min-w-0 items-center gap-1.5">
-        <p className="truncate text-sm font-semibold text-foreground">
-          {issue.title}
-        </p>
-        <status.icon className={`h-3.5 w-3.5 shrink-0 ${status.className}`} />
+        <p className={PROJECT_LIST_ROW_TITLE_CLASS}>{issue.title}</p>
       </div>
-      <p className="truncate text-xs text-muted-foreground">
-        {project.name} · created {formatRelativeTime(issue.createdAt)} by{" "}
+      <p className={`truncate ${PROJECT_LIST_ROW_SUBTEXT_CLASS}`}>
+        {project.name}
+        {includeDate
+          ? ` · created ${formatRelativeTime(issue.createdAt)}`
+          : null}{" "}
+        · by{" "}
         <UserProfilePopover pubkey={issue.author} triggerElement="span">
           <button
             className="relative z-10 rounded-sm hover:underline focus-visible:outline-hidden focus-visible:ring-1 focus-visible:ring-ring"
@@ -87,6 +92,14 @@ function IssueHeader({
             {authorLabel}
           </button>
         </UserProfilePopover>
+        {includeDate ? (
+          ` · ${issue.status}`
+        ) : (
+          <>
+            <span className="md:hidden"> · </span>
+            <span className="md:hidden">{issue.status}</span>
+          </>
+        )}
       </p>
     </div>
   );
@@ -114,6 +127,7 @@ function IssueGridCard({
       </button>
       <div className="flex min-h-0 flex-1 flex-col gap-3">
         <div className="flex min-w-0 items-start gap-3">
+          <ProjectEventTypeIcon className="h-5 w-5" kind="issue" />
           <IssueHeader issue={issue} profiles={profiles} project={project} />
           <Button
             className="relative z-10 h-7 shrink-0 px-2.5"
@@ -165,7 +179,10 @@ function IssueListRow({
   project: Project;
 }) {
   return (
-    <div className="group relative px-4 py-2.5 transition-colors duration-150 hover:bg-muted/20">
+    <div
+      className={PROJECT_LIST_ROW_CLASS}
+      data-testid={`projects-issue-row-${issue.id}`}
+    >
       <button
         className="absolute inset-0"
         onClick={() => onOpen(project, issue)}
@@ -173,21 +190,37 @@ function IssueListRow({
       >
         <span className="sr-only">View {issue.title}</span>
       </button>
-      <div className="flex min-w-0 items-start gap-3">
-        <IssueHeader issue={issue} profiles={profiles} project={project} />
-        <div className="relative z-10 flex shrink-0 items-center gap-2">
-          <Button
-            className="h-7 px-2.5"
-            onClick={(event) => {
-              event.stopPropagation();
-              onOpen(project, issue);
-            }}
-            size="xs"
-            type="button"
-            variant="outline"
+      <div className={PROJECT_LIST_ROW_CONTENT_CLASS}>
+        <ProjectEventTypeIcon className="h-5 w-5" kind="issue" />
+        <IssueHeader
+          includeDate={false}
+          issue={issue}
+          profiles={profiles}
+          project={project}
+        />
+        <div className={PROJECT_LIST_ROW_TRAILING_CLASS}>
+          <span className={PROJECT_LIST_ROW_STATUS_CLASS}>{issue.status}</span>
+          <div className="hidden w-14 shrink-0 justify-end md:flex">
+            {issue.comments.length > 0 ? (
+              <span className="flex items-center gap-1 text-2xs leading-3 text-muted-foreground">
+                <MessageSquare className="h-3.5 w-3.5" />
+                {issue.comments.length}
+              </span>
+            ) : null}
+          </div>
+          <span
+            className={PROJECT_LIST_ROW_DATE_CLASS}
+            data-testid="projects-row-date"
+            title={new Date(issue.createdAt * 1_000).toLocaleString()}
           >
-            {nextStepLabel(issue.status)}
-          </Button>
+            {formatRelativeTime(issue.createdAt)}
+          </span>
+          <ProjectListRowMenu label={`More options for ${issue.title}`}>
+            <DropdownMenuItem onSelect={() => onOpen(project, issue)}>
+              <Eye className="h-4 w-4" />
+              {nextStepLabel(issue.status)}
+            </DropdownMenuItem>
+          </ProjectListRowMenu>
         </div>
       </div>
     </div>
@@ -234,7 +267,7 @@ export function ProjectsIssuesList({
   }
 
   return (
-    <div className="-mx-4 divide-y divide-border/60 border-y border-border/60 bg-card">
+    <div className={PROJECT_LIST_CONTAINER_CLASS}>
       {issues.map(({ project, issue }) => (
         <IssueListRow
           issue={issue}
diff --git a/desktop/src/features/projects/ui/ProjectsListScopeDropdown.tsx b/desktop/src/features/projects/ui/ProjectsListScopeDropdown.tsx
new file mode 100644
index 0000000000..a8a42f0693
--- /dev/null
+++ b/desktop/src/features/projects/ui/ProjectsListScopeDropdown.tsx
@@ -0,0 +1,52 @@
+import { Check, ChevronDown } from "lucide-react";
+
+import { Button } from "@/shared/ui/button";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuTrigger,
+} from "@/shared/ui/dropdown-menu";
+
+export function ProjectsListScopeDropdown<T extends string>({
+  label,
+  onChange,
+  options,
+  value,
+}: {
+  label: string;
+  onChange: (value: T) => void;
+  options: Array<{ label: string; value: T }>;
+  value: T;
+}) {
+  const selectedLabel =
+    options.find((option) => option.value === value)?.label ??
+    options[0]?.label;
+
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger asChild>
+        <Button
+          aria-label={label}
+          className="-ml-2 h-8 gap-1.5 px-2 text-sm font-semibold"
+          variant="ghost"
+        >
+          {selectedLabel}
+          <ChevronDown className="h-4 w-4 text-muted-foreground" />
+        </Button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="start" className="min-w-44">
+        {options.map((option) => (
+          <DropdownMenuItem
+            className="justify-between"
+            key={option.value}
+            onSelect={() => onChange(option.value)}
+          >
+            {option.label}
+            {option.value === value ? <Check className="h-4 w-4" /> : null}
+          </DropdownMenuItem>
+        ))}
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
diff --git a/desktop/src/features/projects/ui/ProjectsOverviewPanel.tsx b/desktop/src/features/projects/ui/ProjectsOverviewPanel.tsx
index 89bad9a3fe..3640af904e 100644
--- a/desktop/src/features/projects/ui/ProjectsOverviewPanel.tsx
+++ b/desktop/src/features/projects/ui/ProjectsOverviewPanel.tsx
@@ -5,10 +5,6 @@ import type {
   Project,
   ProjectActivitySummary,
 } from "@/features/projects/hooks";
-import {
-  ProjectsContributionGraph,
-  ProjectsContributionLegend,
-} from "./ProjectsContributionGraph";
 
 export type ProjectsOverviewSection =
   | "repositories"
@@ -41,21 +37,6 @@ function overviewStats(
   );
 }
 
-function overviewActivityByDay(
-  projects: Project[],
-  summaries: Record<string, ProjectActivitySummary> | undefined,
-) {
-  const merged: Record<string, number> = {};
-  for (const project of projects) {
-    const byDay = summaries?.[project.repoAddress]?.activityByDay;
-    if (!byDay) continue;
-    for (const [day, count] of Object.entries(byDay)) {
-      merged[day] = (merged[day] ?? 0) + count;
-    }
-  }
-  return merged;
-}
-
 function StatPill({
   count,
   icon: Icon,
@@ -95,7 +76,6 @@ export function ProjectsOverviewPanel({
   summaries,
 }: ProjectsOverviewPanelProps) {
   const stats = overviewStats(projects, summaries);
-  const activityByDay = overviewActivityByDay(projects, summaries);
 
   return (
     <section className="-mx-4 mb-4 bg-card">
@@ -126,22 +106,8 @@ export function ProjectsOverviewPanel({
             onClick={() => onSelectSection("issues")}
           />
         </div>
-        <div className="order-2 min-w-0 overflow-hidden xl:order-none xl:col-start-1 xl:row-start-2">
-          <div className="flex items-center justify-between gap-3 px-4 pt-3">
-            <h3 className="text-base font-semibold text-foreground">
-              Contribution Activity
-            </h3>
-            <ProjectsContributionLegend />
-          </div>
-          <div className="overflow-x-auto xl:overflow-visible">
-            <ProjectsContributionGraph
-              activityByDay={activityByDay}
-              className="min-w-[32rem] p-4"
-            />
-          </div>
-        </div>
         {metadata}
-        <div className="order-3 min-w-0 p-4 pt-2 xl:order-none xl:col-start-1 xl:row-start-3">
+        <div className="order-2 min-w-0 p-4 pt-2 xl:order-none xl:col-start-1 xl:row-start-2">
           {children}
         </div>
       </div>
diff --git a/desktop/src/features/projects/ui/ProjectsOverviewRail.tsx b/desktop/src/features/projects/ui/ProjectsOverviewRail.tsx
index bb0dd9d8e9..9f77cf102c 100644
--- a/desktop/src/features/projects/ui/ProjectsOverviewRail.tsx
+++ b/desktop/src/features/projects/ui/ProjectsOverviewRail.tsx
@@ -1,5 +1,3 @@
-import type { ReactNode } from "react";
-
 import {
   resolveUserLabel,
   type UserProfileLookup,
@@ -7,23 +5,16 @@ import {
 import type {
   Project,
   ProjectActivitySummary,
-  ProjectRepoSnapshot,
 } from "@/features/projects/hooks";
-import {
-  languageForPath,
-  topLanguagesFromCounts,
-} from "@/features/projects/lib/projectLanguages";
 import { normalizePubkey } from "@/shared/lib/pubkey";
 import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
 import { UserAvatar } from "@/shared/ui/UserAvatar";
-import { LanguageChips, OverviewRailSection } from "./ProjectOverviewPanel";
+import { OverviewRailSection } from "./ProjectOverviewPanel";
+import { ProjectsContributionGraph } from "./ProjectsContributionGraph";
 
 type ProjectsOverviewRailProps = {
-  children: ReactNode;
   profiles?: UserProfileLookup;
   projects: Project[];
-  snapshots?: Record<string, ProjectRepoSnapshot>;
-  snapshotsLoading?: boolean;
   summaries?: Record<string, ProjectActivitySummary>;
 };
 
@@ -44,30 +35,29 @@ function overviewPeople(
   ];
 }
 
-function overviewLanguages(
-  snapshots: Record<string, ProjectRepoSnapshot> | undefined,
+function overviewActivityByDay(
+  projects: Project[],
+  summaries: Record<string, ProjectActivitySummary> | undefined,
 ) {
-  const counts: Record<string, number> = {};
-  for (const snapshot of Object.values(snapshots ?? {})) {
-    for (const file of snapshot.files) {
-      const language = languageForPath(file.path);
-      if (language) counts[language] = (counts[language] ?? 0) + 1;
+  const merged: Record<string, number> = {};
+  for (const project of projects) {
+    const byDay = summaries?.[project.repoAddress]?.activityByDay;
+    if (!byDay) continue;
+    for (const [day, count] of Object.entries(byDay)) {
+      merged[day] = (merged[day] ?? 0) + count;
     }
   }
-  return topLanguagesFromCounts(counts);
+  return merged;
 }
 
-/** Workspace people and language metadata for the overview side rail. */
+/** Workspace people and contribution activity for the overview side rail. */
 export function ProjectsOverviewRail({
-  children,
   profiles,
   projects,
-  snapshots,
-  snapshotsLoading,
   summaries,
 }: ProjectsOverviewRailProps) {
   const people = overviewPeople(projects, summaries);
-  const languages = overviewLanguages(snapshots);
+  const activityByDay = overviewActivityByDay(projects, summaries);
 
   return (
     <>
@@ -101,25 +91,13 @@ export function ProjectsOverviewRail({
         </OverviewRailSection>
       </div>
 
-      <div className="order-5 min-w-0 space-y-7 border-t border-border/40 px-4 pb-4 pt-3 xl:order-none xl:col-start-2 xl:row-span-2 xl:row-start-2 xl:border-t-0">
-        <OverviewRailSection title="Top Languages" titleClassName="text-base">
-          {languages.length > 0 ? (
-            <LanguageChips languages={languages} />
-          ) : (
-            <p className="text-sm text-muted-foreground">
-              {snapshotsLoading
-                ? "Scanning repositories..."
-                : "No language data is available yet."}
-            </p>
-          )}
-        </OverviewRailSection>
-
-        <OverviewRailSection
-          title="Active Repositories"
-          titleClassName="text-base"
-        >
-          {children}
-        </OverviewRailSection>
+      <div className="order-5 min-w-0 border-t border-border/40 px-4 pb-4 pt-3 xl:order-none xl:col-start-2 xl:row-start-2 xl:border-t-0">
+        <section className="space-y-2">
+          <h3 className="text-base font-semibold text-foreground">
+            Contribution Activity
+          </h3>
+          <ProjectsContributionGraph activityByDay={activityByDay} compact />
+        </section>
       </div>
     </>
   );
diff --git a/desktop/src/features/projects/ui/ProjectsPullRequestsList.tsx b/desktop/src/features/projects/ui/ProjectsPullRequestsList.tsx
index aff1fddc29..36f9005a05 100644
--- a/desktop/src/features/projects/ui/ProjectsPullRequestsList.tsx
+++ b/desktop/src/features/projects/ui/ProjectsPullRequestsList.tsx
@@ -1,4 +1,4 @@
-import { Check, MessageSquare, X } from "lucide-react";
+import { GitPullRequest, MessageSquare } from "lucide-react";
 
 import type {
   Project,
@@ -10,10 +10,21 @@ import {
   type UserProfileLookup,
 } from "@/features/profile/lib/identity";
 import { UserProfilePopover } from "@/features/profile/ui/UserProfilePopover";
-import { normalizePubkey } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
 import { Card } from "@/shared/ui/card";
-import { UserAvatar } from "@/shared/ui/UserAvatar";
+import { DropdownMenuItem } from "@/shared/ui/dropdown-menu";
+import { ProjectEventTypeIcon } from "./ProjectEventTypeIcon";
+import { ProjectListRowMenu } from "./ProjectListRowMenu";
+import {
+  PROJECT_LIST_CONTAINER_CLASS,
+  PROJECT_LIST_ROW_CLASS,
+  PROJECT_LIST_ROW_CONTENT_CLASS,
+  PROJECT_LIST_ROW_DATE_CLASS,
+  PROJECT_LIST_ROW_STATUS_CLASS,
+  PROJECT_LIST_ROW_SUBTEXT_CLASS,
+  PROJECT_LIST_ROW_TITLE_CLASS,
+  PROJECT_LIST_ROW_TRAILING_CLASS,
+} from "./projectListRowStyles";
 
 /** Author name that opens the user profile popover. */
 function AuthorNameButton({
@@ -62,13 +73,6 @@ function formatRelativeTime(createdAt: number) {
   return `${value} ${unit.label}${value === 1 ? "" : "s"} ago`;
 }
 
-function pullRequestStatusClassName(status: ProjectPullRequest["status"]) {
-  if (status === "Closed") return "text-destructive";
-  if (status === "Draft") return "text-muted-foreground";
-  if (status === "Merged") return "text-purple-400";
-  return "text-green-500";
-}
-
 function nextStepLabel(status: ProjectPullRequest["status"]) {
   if (status === "Draft") return "View draft";
   if (status === "Merged") return "View merge";
@@ -91,11 +95,6 @@ function PullRequestGridCard({
     profiles,
     pubkey: pullRequest.author,
   });
-  const authorProfile = profiles?.[normalizePubkey(pullRequest.author)];
-  const StatusIcon =
-    pullRequest.status === "Closed" || pullRequest.status === "Draft"
-      ? X
-      : Check;
 
   return (
     <Card className="group relative flex min-h-40 flex-col overflow-hidden border-border/60 bg-card p-4 shadow-none transition-colors duration-150 hover:bg-muted/20">
@@ -108,30 +107,12 @@ function PullRequestGridCard({
       </button>
       <div className="flex min-h-0 flex-1 flex-col gap-3">
         <div className="flex min-w-0 items-start gap-3">
-          <UserProfilePopover pubkey={pullRequest.author} triggerElement="span">
-            <button
-              aria-label={`View ${authorLabel}'s profile`}
-              className="relative z-10 inline-flex shrink-0 rounded-full focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring"
-              type="button"
-            >
-              <UserAvatar
-                accent={authorProfile?.isAgent === true}
-                avatarUrl={authorProfile?.avatarUrl ?? null}
-                displayName={authorLabel}
-                size="md"
-              />
-            </button>
-          </UserProfilePopover>
+          <ProjectEventTypeIcon className="h-5 w-5" kind="pull-request" />
           <div className="min-w-0 flex-1 space-y-1">
             <div className="flex min-w-0 items-center gap-1.5">
               <p className="truncate text-sm font-semibold text-foreground">
                 {pullRequest.title}
               </p>
-              <StatusIcon
-                className={`h-3.5 w-3.5 shrink-0 ${pullRequestStatusClassName(
-                  pullRequest.status,
-                )}`}
-              />
             </div>
             <p className="truncate text-xs text-muted-foreground">
               {project.name}
@@ -201,14 +182,12 @@ function PullRequestListRow({
     profiles,
     pubkey: pullRequest.author,
   });
-  const authorProfile = profiles?.[normalizePubkey(pullRequest.author)];
-  const StatusIcon =
-    pullRequest.status === "Closed" || pullRequest.status === "Draft"
-      ? X
-      : Check;
 
   return (
-    <div className="group relative px-4 py-2.5 transition-colors duration-150 hover:bg-muted/20">
+    <div
+      className={PROJECT_LIST_ROW_CLASS}
+      data-testid={`projects-pr-row-${pullRequest.id}`}
+    >
       <button
         className="absolute inset-0"
         onClick={() => onOpen(project, pullRequest)}
@@ -216,39 +195,20 @@ function PullRequestListRow({
       >
         <span className="sr-only">View {pullRequest.title}</span>
       </button>
-      <div className="flex min-w-0 items-start gap-3">
-        <UserProfilePopover pubkey={pullRequest.author} triggerElement="span">
-          <button
-            aria-label={`View ${authorLabel}'s profile`}
-            className="relative z-10 inline-flex shrink-0 rounded-full focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring"
-            type="button"
-          >
-            <UserAvatar
-              accent={authorProfile?.isAgent === true}
-              avatarUrl={authorProfile?.avatarUrl ?? null}
-              displayName={authorLabel}
-              size="md"
-            />
-          </button>
-        </UserProfilePopover>
-        <div className="min-w-0 flex-1 space-y-1">
+      <div className={PROJECT_LIST_ROW_CONTENT_CLASS}>
+        <ProjectEventTypeIcon className="h-5 w-5" kind="pull-request" />
+        <div className="-mt-0.5 min-w-0 flex-1">
           <div className="flex min-w-0 items-center gap-1.5">
-            <p className="truncate text-sm font-semibold text-foreground">
-              {pullRequest.title}
-            </p>
-            <StatusIcon
-              className={`h-3.5 w-3.5 shrink-0 ${pullRequestStatusClassName(
-                pullRequest.status,
-              )}`}
-            />
+            <p className={PROJECT_LIST_ROW_TITLE_CLASS}>{pullRequest.title}</p>
           </div>
-          <div className="flex min-w-0 flex-wrap items-center gap-x-1.5 gap-y-0.5 text-xs text-foreground/80">
+          <div
+            className={`flex min-w-0 items-center gap-x-1.5 overflow-hidden whitespace-nowrap ${PROJECT_LIST_ROW_SUBTEXT_CLASS}`}
+          >
             <span>{project.name}</span>
             <span>·</span>
             <span className="font-mono text-foreground">
               #{pullRequest.id.slice(0, 8)}
             </span>
-            <span>created {formatRelativeTime(pullRequest.createdAt)}</span>
             <span>
               by{" "}
               <AuthorNameButton
@@ -256,29 +216,35 @@ function PullRequestListRow({
                 pubkey={pullRequest.author}
               />
             </span>
-            <span>·</span>
-            <span>{pullRequest.status}</span>
+            <span className="md:hidden">·</span>
+            <span className="md:hidden">{pullRequest.status}</span>
           </div>
         </div>
-        <div className="relative z-10 flex shrink-0 items-center gap-2">
-          {pullRequest.comments.length > 0 ? (
-            <span className="flex items-center gap-1 text-xs text-muted-foreground">
-              <MessageSquare className="h-3.5 w-3.5" />
-              {pullRequest.comments.length}
-            </span>
-          ) : null}
-          <Button
-            className="h-7 px-2.5"
-            onClick={(event) => {
-              event.stopPropagation();
-              onOpen(project, pullRequest);
-            }}
-            size="xs"
-            type="button"
-            variant="outline"
+        <div className={PROJECT_LIST_ROW_TRAILING_CLASS}>
+          <span className={PROJECT_LIST_ROW_STATUS_CLASS}>
+            {pullRequest.status}
+          </span>
+          <div className="hidden w-14 shrink-0 justify-end md:flex">
+            {pullRequest.comments.length > 0 ? (
+              <span className="flex items-center gap-1 text-2xs leading-3 text-muted-foreground">
+                <MessageSquare className="h-3.5 w-3.5" />
+                {pullRequest.comments.length}
+              </span>
+            ) : null}
+          </div>
+          <span
+            className={PROJECT_LIST_ROW_DATE_CLASS}
+            data-testid="projects-row-date"
+            title={new Date(pullRequest.createdAt * 1_000).toLocaleString()}
           >
-            {nextStepLabel(pullRequest.status)}
-          </Button>
+            {formatRelativeTime(pullRequest.createdAt)}
+          </span>
+          <ProjectListRowMenu label={`More options for ${pullRequest.title}`}>
+            <DropdownMenuItem onSelect={() => onOpen(project, pullRequest)}>
+              <GitPullRequest className="h-4 w-4" />
+              {nextStepLabel(pullRequest.status)}
+            </DropdownMenuItem>
+          </ProjectListRowMenu>
         </div>
       </div>
     </div>
@@ -325,7 +291,7 @@ export function ProjectsPullRequestsList({
   }
 
   return (
-    <div className="-mx-4 divide-y divide-border/60 border-y border-border/60 bg-card">
+    <div className={PROJECT_LIST_CONTAINER_CLASS}>
       {pullRequests.map(({ project, pullRequest }) => (
         <PullRequestListRow
           key={pullRequest.id}
diff --git a/desktop/src/features/projects/ui/ProjectsToolbar.tsx b/desktop/src/features/projects/ui/ProjectsToolbar.tsx
index 0efbb91675..5e4ee73204 100644
--- a/desktop/src/features/projects/ui/ProjectsToolbar.tsx
+++ b/desktop/src/features/projects/ui/ProjectsToolbar.tsx
@@ -8,7 +8,7 @@ import { cn } from "@/shared/lib/cn";
 import { Button } from "@/shared/ui/button";
 
 const SELECTED_MENU_ITEM_CLASSES =
-  "bg-sidebar-active text-sidebar-active-foreground shadow-xs hover:bg-sidebar-active hover:text-sidebar-active-foreground";
+  "font-semibold text-foreground after:opacity-100 hover:text-foreground";
 
 type ProjectsToolbarProps = {
   filter: ProjectsFilter;
@@ -56,52 +56,46 @@ export function ProjectsToolbar({
   onFilterChange,
 }: ProjectsToolbarProps) {
   const filterOptions: Array<{
-    compactLabel?: string;
     label: string;
     value: ProjectsFilter;
   }> = [
     { label: "Overview", value: "all" },
-    {
-      compactLabel: "Repos",
-      label: "Repositories",
-      value: "repositories",
-    },
-    { compactLabel: "PRs", label: "Pull Requests", value: "prs" },
+    { label: "Repositories", value: "repositories" },
+    { label: "Pull Requests", value: "prs" },
     { label: "Issues", value: "issues" },
-    { compactLabel: "Mine", label: "My Repositories", value: "mine" },
-    { label: "Local", value: "local" },
   ];
 
   return (
     <div
-      className="pointer-events-auto flex min-h-[3.25rem] min-w-0 items-center px-4 py-2"
+      className="pointer-events-auto flex h-full min-w-0 items-center"
       data-tauri-drag-region
     >
-      <div className="flex min-w-0 flex-1 items-center gap-0.5 overflow-hidden">
-        <fieldset className="flex min-w-0 flex-1 flex-nowrap items-center gap-1 overflow-x-auto scrollbar-none [&::-webkit-scrollbar]:hidden">
+      <div className="flex h-full min-w-0 flex-1 items-center gap-0.5 overflow-hidden">
+        <fieldset className="flex h-full min-w-0 flex-1 flex-nowrap items-stretch gap-1 overflow-x-auto scrollbar-none [&::-webkit-scrollbar]:hidden">
           <legend className="sr-only">Project owner filter</legend>
           {filterOptions.map((option) => (
             <Button
               aria-label={option.label}
               aria-pressed={filter === option.value}
               className={cn(
-                "h-8 shrink-0 gap-1.5 rounded-full px-3 text-xs xl:px-3.5 xl:text-sm",
+                "relative h-full shrink-0 gap-1.5 rounded-none px-2.5 text-base leading-5 tracking-tight text-muted-foreground after:absolute after:inset-x-2.5 after:bottom-0 after:h-0.5 after:bg-current after:opacity-0 after:transition-opacity after:content-[''] hover:bg-transparent hover:text-foreground hover:after:opacity-100",
+                option.value === "all" && "pl-0 after:left-0",
                 filter === option.value && SELECTED_MENU_ITEM_CLASSES,
               )}
               key={option.value}
               onClick={() => onFilterChange(option.value)}
-              size="sm"
               type="button"
               variant="ghost"
             >
-              {option.compactLabel ? (
-                <>
-                  <span className="xl:hidden">{option.compactLabel}</span>
-                  <span className="hidden xl:inline">{option.label}</span>
-                </>
-              ) : (
-                option.label
-              )}
+              <span className="grid">
+                <span
+                  aria-hidden="true"
+                  className="invisible col-start-1 row-start-1 font-semibold"
+                >
+                  {option.label}
+                </span>
+                <span className="col-start-1 row-start-1">{option.label}</span>
+              </span>
             </Button>
           ))}
         </fieldset>
diff --git a/desktop/src/features/projects/ui/ProjectsView.tsx b/desktop/src/features/projects/ui/ProjectsView.tsx
index ed7a5723be..a8a2d3bf6a 100644
--- a/desktop/src/features/projects/ui/ProjectsView.tsx
+++ b/desktop/src/features/projects/ui/ProjectsView.tsx
@@ -1,4 +1,3 @@
-import { Plus } from "lucide-react";
 import * as React from "react";
 import { toast } from "sonner";
 
@@ -23,13 +22,17 @@ import {
   EmptyState,
   ProjectGridCard,
   ProjectListRow,
-  ProjectRailRow,
 } from "@/features/projects/ui/ProjectCards";
 import { CreateProjectDialog } from "@/features/projects/ui/CreateProjectDialog";
+import { CreateProjectIssueDialog } from "@/features/projects/ui/CreateProjectIssueDialog";
+import { CreatePullRequestDialog } from "@/features/projects/ui/CreatePullRequestDialog";
+import { ProjectsCreateMenu } from "@/features/projects/ui/ProjectsCreateMenu";
 import { ProjectsIssuesList } from "@/features/projects/ui/ProjectsIssuesList";
 import { ProjectsOverviewPanel } from "@/features/projects/ui/ProjectsOverviewPanel";
 import { ProjectsOverviewRail } from "@/features/projects/ui/ProjectsOverviewRail";
 import { ProjectsPullRequestsList } from "@/features/projects/ui/ProjectsPullRequestsList";
+import { ProjectsListScopeDropdown } from "@/features/projects/ui/ProjectsListScopeDropdown";
+import { PROJECT_LIST_CONTAINER_CLASS } from "@/features/projects/ui/projectListRowStyles";
 import {
   ProjectsToolbar,
   ProjectsViewModeToggle,
@@ -43,26 +46,56 @@ import {
   projectOwnerIsUser,
   projectPeople,
   type ProjectsFilter,
+  type ProjectsRepositoryScope,
   type ProjectsSort,
   type ProjectsViewMode,
+  type ProjectsWorkItemScope,
   readStoredFilter,
+  readStoredIssueScope,
+  readStoredPullRequestScope,
+  readStoredRepositoryScope,
   readStoredSort,
   readStoredViewMode,
   uniqueRepositories,
   writeStoredFilter,
+  writeStoredIssueScope,
+  writeStoredPullRequestScope,
+  writeStoredRepositoryScope,
   writeStoredSort,
   writeStoredViewMode,
 } from "@/features/projects/lib/projectsViewHelpers";
 import { useOpenProjectTerminal } from "@/features/projects/ui/useOpenProjectTerminal";
 import { useCommunities } from "@/features/communities/useCommunities";
-import { CommunityEmojiIcon } from "@/features/communities/ui/CommunitySwitcher";
 import { useIdentityQuery } from "@/shared/api/hooks";
 import { topChromeInset } from "@/shared/layout/chromeLayout";
 import { cn } from "@/shared/lib/cn";
 import { normalizePubkey } from "@/shared/lib/pubkey";
 import { Button } from "@/shared/ui/button";
+import { PageHeader } from "@/shared/ui/PageHeader";
 
 const MANY_PROJECTS_THRESHOLD = 12;
+const REPOSITORY_SCOPE_OPTIONS: Array<{
+  label: string;
+  value: ProjectsRepositoryScope;
+}> = [
+  { label: "All", value: "all" },
+  { label: "My Repositories", value: "mine" },
+  { label: "Local", value: "local" },
+];
+const PULL_REQUEST_SCOPE_OPTIONS: Array<{
+  label: string;
+  value: ProjectsWorkItemScope;
+}> = [
+  { label: "All", value: "all" },
+  { label: "My Pull Requests", value: "mine" },
+];
+const ISSUE_SCOPE_OPTIONS: Array<{
+  label: string;
+  value: ProjectsWorkItemScope;
+}> = [
+  { label: "All", value: "all" },
+  { label: "My Issues", value: "mine" },
+];
 
 export function ProjectsView() {
   const { goProject } = useAppNavigation();
@@ -114,8 +147,18 @@ export function ProjectsView() {
     activeCommunity?.reposDir,
   );
   const projectPullRequestsQuery = useProjectsPullRequestsQuery(projects);
-  const [filter, setFilter] = React.useState<ProjectsFilter>(() =>
-    readStoredFilter(),
+  const [filter, setFilter] = React.useState<ProjectsFilter>(() => {
+    const storedFilter = readStoredFilter();
+    return storedFilter === "mine" || storedFilter === "local"
+      ? "repositories"
+      : storedFilter;
+  });
+  const [repositoryScope, setRepositoryScope] =
+    React.useState<ProjectsRepositoryScope>(() => readStoredRepositoryScope());
+  const [pullRequestScope, setPullRequestScope] =
+    React.useState<ProjectsWorkItemScope>(() => readStoredPullRequestScope());
+  const [issueScope, setIssueScope] = React.useState<ProjectsWorkItemScope>(
+    () => readStoredIssueScope(),
   );
   const projectIssuesQuery = useProjectsIssuesQuery(
     filter === "issues" || filter === "all" ? projects : [],
@@ -131,6 +174,9 @@ export function ProjectsView() {
     activeCommunity?.reposDir,
   );
   const [createProjectOpen, setCreateProjectOpen] = React.useState(false);
+  const [createIssueOpen, setCreateIssueOpen] = React.useState(false);
+  const [createPullRequestOpen, setCreatePullRequestOpen] =
+    React.useState(false);
   const createProjectMutation = useCreateProjectMutation();
   const [storedViewMode, setStoredViewMode] =
     React.useState<ProjectsViewMode | null>(() => readStoredViewMode());
@@ -192,6 +238,30 @@ export function ProjectsView() {
     writeStoredFilter(nextFilter);
   }, []);
 
+  const handleRepositoryScopeChange = React.useCallback(
+    (scope: ProjectsRepositoryScope) => {
+      setRepositoryScope(scope);
+      writeStoredRepositoryScope(scope);
+    },
+    [],
+  );
+
+  const handlePullRequestScopeChange = React.useCallback(
+    (scope: ProjectsWorkItemScope) => {
+      setPullRequestScope(scope);
+      writeStoredPullRequestScope(scope);
+    },
+    [],
+  );
+
+  const handleIssueScopeChange = React.useCallback(
+    (scope: ProjectsWorkItemScope) => {
+      setIssueScope(scope);
+      writeStoredIssueScope(scope);
+    },
+    [],
+  );
+
   const handleSortChange = React.useCallback((nextSort: ProjectsSort) => {
     setSort(nextSort);
     writeStoredSort(nextSort);
@@ -227,8 +297,9 @@ export function ProjectsView() {
       .filter((project) => {
         const summary = activitySummariesQuery.data?.[project.repoAddress];
         const people = projectPeople(project, summary);
-        if (filter === "mine") return isProjectMine(project, currentPubkey);
-        if (filter === "local")
+        if (repositoryScope === "mine")
+          return isProjectMine(project, currentPubkey);
+        if (repositoryScope === "local")
           return hasLocalCheckout(project, localRepoNames);
         if (filter === "agents") {
           return projectHasAgent(project, people, profiles);
@@ -261,12 +332,21 @@ export function ProjectsView() {
     localRepoNames,
     profiles,
     projects,
+    repositoryScope,
     sort,
   ]);
 
   const visiblePullRequests = React.useMemo(() => {
     const pullRequests = projectPullRequestsQuery.data ?? [];
-    return [...pullRequests].sort((left, right) => {
+    const scopedPullRequests =
+      pullRequestScope === "mine" && currentPubkey
+        ? pullRequests.filter(
+            ({ pullRequest }) =>
+              normalizePubkey(pullRequest.author) ===
+              normalizePubkey(currentPubkey),
+          )
+        : pullRequests;
+    return [...scopedPullRequests].sort((left, right) => {
       if (sort === "name") {
         return left.pullRequest.title.localeCompare(right.pullRequest.title);
       }
@@ -275,11 +355,18 @@ export function ProjectsView() {
       }
       return right.pullRequest.updatedAt - left.pullRequest.updatedAt;
     });
-  }, [projectPullRequestsQuery.data, sort]);
+  }, [currentPubkey, projectPullRequestsQuery.data, pullRequestScope, sort]);
 
   const visibleIssues = React.useMemo(() => {
     const issues = projectIssuesQuery.data ?? [];
-    return [...issues].sort((left, right) => {
+    const scopedIssues =
+      issueScope === "mine" && currentPubkey
+        ? issues.filter(
+            ({ issue }) =>
+              normalizePubkey(issue.author) === normalizePubkey(currentPubkey),
+          )
+        : issues;
+    return [...scopedIssues].sort((left, right) => {
       if (sort === "name") {
         return left.issue.title.localeCompare(right.issue.title);
       }
@@ -288,7 +375,7 @@ export function ProjectsView() {
       }
       return right.issue.updatedAt - left.issue.updatedAt;
     });
-  }, [projectIssuesQuery.data, sort]);
+  }, [currentPubkey, issueScope, projectIssuesQuery.data, sort]);
 
   // Route by the canonical `owner:dtag` project ID — a bare dtag is
   // ambiguous across owners (forks can share the same dtag).
@@ -396,7 +483,7 @@ export function ProjectsView() {
         })}
       </div>
     ) : (
-      <div className="-mx-4 divide-y divide-border/60 border-y border-border/60 bg-card">
+      <div className={PROJECT_LIST_CONTAINER_CLASS}>
         {visibleProjects.map((project) => {
           const summary = activitySummariesQuery.data?.[project.repoAddress];
           return (
@@ -418,43 +505,6 @@ export function ProjectsView() {
       </div>
     );
 
-  const mostActiveProjects = [...projects]
-    .sort((left, right) => {
-      const leftSummary = activitySummariesQuery.data?.[left.repoAddress];
-      const rightSummary = activitySummariesQuery.data?.[right.repoAddress];
-      const activityDifference =
-        (rightSummary?.activityCount ?? 0) - (leftSummary?.activityCount ?? 0);
-      if (activityDifference !== 0) return activityDifference;
-      // `updatedAt: 0` means a summary exists but recorded no activity —
-      // treat it like a missing summary and use the announcement time.
-      return (
-        (rightSummary?.updatedAt || right.createdAt) -
-        (leftSummary?.updatedAt || left.createdAt)
-      );
-    })
-    .slice(0, 3);
-
-  const mostActiveRepositoryItems =
-    mostActiveProjects.length === 0 ? (
-      <p className="px-2 py-8 text-center text-sm text-muted-foreground">
-        No repository activity yet
-      </p>
-    ) : (
-      <div className="space-y-1">
-        {mostActiveProjects.map((project) => {
-          const summary = activitySummariesQuery.data?.[project.repoAddress];
-          return (
-            <ProjectRailRow
-              key={project.id}
-              onOpen={handleOpenProject}
-              project={project}
-              summary={summary}
-            />
-          );
-        })}
-      </div>
-    );
-
   const listControls = (
     <div className="flex flex-wrap items-center gap-2 sm:justify-end">
       <label className="flex items-center gap-2 text-xs text-muted-foreground">
@@ -497,23 +547,29 @@ export function ProjectsView() {
     />
   );
 
+  const createMenu = (
+    <ProjectsCreateMenu
+      onCreateIssue={() => setCreateIssueOpen(true)}
+      onCreatePullRequest={() => setCreatePullRequestOpen(true)}
+      onCreateRepository={() => setCreateProjectOpen(true)}
+    />
+  );
+
   const projectsHeader = (
-    <div className="pointer-events-auto flex min-w-0 items-center gap-3 px-4 pb-1 pt-4">
-      <CommunityEmojiIcon className="flex h-12 w-12 shrink-0 items-center justify-center rounded-xl border border-border/60 bg-muted/40 text-3xl" />
-      <div className="min-w-0 flex-1 space-y-0.5">
-        <h2 className="text-xl font-semibold leading-6 tracking-tight text-foreground">
-          {activeCommunity?.name || "Relay"} Projects
-        </h2>
-        <p className="line-clamp-2 max-w-2xl text-base font-normal text-muted-foreground sm:line-clamp-none">
-          Browse shared repositories, pull requests, and local project checkouts
-          in this workspace.
-        </p>
-      </div>
-    </div>
+    <PageHeader
+      className="pointer-events-auto mb-8"
+      description="Set up and manage your projects."
+      title={activeCommunity?.name || "Relay"}
+    />
   );
 
-  const renderProjectsToolbar = () => (
-    <ProjectsToolbar filter={filter} onFilterChange={handleFilterChange} />
+  const projectsNavigation = (
+    <div className="flex h-[3.25rem] min-w-0 items-center">
+      <div className="h-full min-w-0 flex-1">
+        <ProjectsToolbar filter={filter} onFilterChange={handleFilterChange} />
+      </div>
+      {createMenu}
+    </div>
   );
 
   return (
@@ -530,23 +586,6 @@ export function ProjectsView() {
         className="pointer-events-none absolute right-[3px] top-0 z-50 w-1 rounded-full bg-border/80 opacity-0 transition-opacity duration-200"
         ref={scrollIndicatorRef}
       />
-      {/* Pinned above the scroll container so it stays put while scrolling. */}
-      <div className="absolute right-4 top-4 z-40">
-        <Button
-          aria-label="Create project"
-          className="group h-8 gap-0 rounded-full px-2 transition-all duration-200 ease-out hover:gap-1.5 hover:px-3"
-          data-testid="create-project-button"
-          onClick={() => setCreateProjectOpen(true)}
-          size="sm"
-          type="button"
-          variant="default"
-        >
-          <Plus className="h-4 w-4 shrink-0" />
-          <span className="max-w-0 overflow-hidden whitespace-nowrap opacity-0 transition-all duration-200 ease-out group-hover:max-w-[4.5rem] group-hover:opacity-100">
-            Project
-          </span>
-        </Button>
-      </div>
       <CreateProjectDialog
         isCreating={createProjectMutation.isPending}
         onCreate={async (input) => {
@@ -554,78 +593,119 @@ export function ProjectsView() {
           toast.success(`Project "${project.name}" created.`);
           // Land on the list that actually shows the new project — the
           // Overview only surfaces the top few most-active repositories.
+          handleRepositoryScopeChange("all");
           handleFilterChange("repositories");
         }}
         onOpenChange={setCreateProjectOpen}
         open={createProjectOpen}
       />
+      {createPullRequestOpen ? (
+        <CreatePullRequestDialog
+          onCreated={async (createdProject, pullRequestId) => {
+            await goProject(createdProject.id, { pullRequestId });
+          }}
+          onOpenChange={setCreatePullRequestOpen}
+          open
+          projects={projects}
+          reposDir={activeCommunity?.reposDir}
+        />
+      ) : null}
+      <CreateProjectIssueDialog
+        onCreated={async (createdProject, issueId) => {
+          await goProject(createdProject.id, { issueId });
+        }}
+        onOpenChange={setCreateIssueOpen}
+        open={createIssueOpen}
+        projects={projects}
+      />
       <div
-        className="buzz-content-scrollbar flex min-h-0 min-w-0 flex-1 flex-col overflow-x-hidden overflow-y-auto"
+        className="buzz-content-scrollbar min-h-0 min-w-0 flex-1 overflow-x-hidden overflow-y-scroll"
         onScroll={handleContentScroll}
       >
-        {projectsHeader}
-        {filter === "all" ? null : (
-          <div className="sticky top-0 z-30 bg-background/80 backdrop-blur-md supports-backdrop-filter:bg-background/70 dark:bg-background/70 dark:backdrop-blur-xl dark:supports-backdrop-filter:bg-background/55">
-            {renderProjectsToolbar()}
+        <div className="px-4 pb-7 pt-7 sm:px-6 sm:pb-8 sm:pt-8">
+          <div className="mx-auto w-full max-w-6xl">{projectsHeader}</div>
+          <div className="sticky top-0 z-30 -mx-4 bg-background/80 backdrop-blur-xl supports-backdrop-filter:bg-background/65 dark:bg-background/75 dark:supports-backdrop-filter:bg-background/60 sm:-mx-6">
+            <div className="px-4 sm:px-6">
+              <div className="mx-auto w-full max-w-6xl">
+                {projectsNavigation}
+              </div>
+            </div>
           </div>
-        )}
-        <div className="w-full min-w-0 px-4 pb-4 pt-4">
-          {filter === "all" ? (
-            <ProjectsOverviewPanel
-              localRepositoryCount={localProjectCount}
-              metadata={
-                <ProjectsOverviewRail
-                  profiles={profiles}
+          <div className="mx-auto w-full max-w-6xl">
+            <div className="w-full min-w-0 pb-4 pt-4">
+              {filter === "all" ? (
+                <ProjectsOverviewPanel
+                  localRepositoryCount={localProjectCount}
+                  metadata={
+                    <ProjectsOverviewRail
+                      profiles={profiles}
+                      projects={projects}
+                      summaries={activitySummariesQuery.data}
+                    />
+                  }
+                  onSelectSection={(section) => {
+                    if (section === "local") {
+                      handleRepositoryScopeChange("local");
+                      handleFilterChange("repositories");
+                      return;
+                    }
+                    handleFilterChange(section);
+                  }}
                   projects={projects}
-                  snapshots={repoSnapshotsQuery.data}
-                  snapshotsLoading={repoSnapshotsQuery.isLoading}
                   summaries={activitySummariesQuery.data}
                 >
-                  {mostActiveRepositoryItems}
-                </ProjectsOverviewRail>
-              }
-              onSelectSection={handleFilterChange}
-              projects={projects}
-              summaries={activitySummariesQuery.data}
-            >
-              <div className="sticky top-0 z-30 -mx-4 mb-4 mt-2 bg-card/80 backdrop-blur-md supports-backdrop-filter:bg-card/70">
-                {renderProjectsToolbar()}
-              </div>
-              <section className="space-y-3">{activityFeed}</section>
-            </ProjectsOverviewPanel>
-          ) : (
-            <section className="space-y-3">
-              <div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
-                <h3 className="text-base font-semibold text-foreground">
-                  {filter === "prs"
-                    ? "Pull requests"
-                    : filter === "issues"
-                      ? "Issues"
-                      : "Repositories"}
-                </h3>
-                {listControls}
-              </div>
-              {filter === "prs" ? (
-                <ProjectsPullRequestsList
-                  isLoading={projectPullRequestsQuery.isLoading}
-                  onOpen={handleOpenPullRequest}
-                  profiles={profiles}
-                  pullRequests={visiblePullRequests}
-                  viewMode={viewMode}
-                />
-              ) : filter === "issues" ? (
-                <ProjectsIssuesList
-                  isLoading={projectIssuesQuery.isLoading}
-                  issues={visibleIssues}
-                  onOpen={handleOpenIssue}
-                  profiles={profiles}
-                  viewMode={viewMode}
-                />
+                  <section className="space-y-3">{activityFeed}</section>
+                </ProjectsOverviewPanel>
               ) : (
-                repositoryItems
+                <section className="space-y-3">
+                  <div className="flex flex-col gap-2 sm:flex-row sm:items-center sm:justify-between">
+                    {filter === "prs" ? (
+                      <ProjectsListScopeDropdown
+                        label="Filter pull requests"
+                        onChange={handlePullRequestScopeChange}
+                        options={PULL_REQUEST_SCOPE_OPTIONS}
+                        value={pullRequestScope}
+                      />
+                    ) : filter === "issues" ? (
+                      <ProjectsListScopeDropdown
+                        label="Filter issues"
+                        onChange={handleIssueScopeChange}
+                        options={ISSUE_SCOPE_OPTIONS}
+                        value={issueScope}
+                      />
+                    ) : (
+                      <ProjectsListScopeDropdown
+                        label="Filter repositories"
+                        onChange={handleRepositoryScopeChange}
+                        options={REPOSITORY_SCOPE_OPTIONS}
+                        value={repositoryScope}
+                      />
+                    )}
+                    {listControls}
+                  </div>
+                  {filter === "prs" ? (
+                    <ProjectsPullRequestsList
+                      isLoading={projectPullRequestsQuery.isLoading}
+                      onOpen={handleOpenPullRequest}
+                      profiles={profiles}
+                      pullRequests={visiblePullRequests}
+                      viewMode={viewMode}
+                    />
+                  ) : filter === "issues" ? (
+                    <ProjectsIssuesList
+                      isLoading={projectIssuesQuery.isLoading}
+                      issues={visibleIssues}
+                      onOpen={handleOpenIssue}
+                      profiles={profiles}
+                      viewMode={viewMode}
+                    />
+                  ) : (
+                    repositoryItems
+                  )}
+                </section>
               )}
-            </section>
-          )}
+            </div>
+          </div>
         </div>
       </div>
     </div>
diff --git a/desktop/src/features/projects/ui/PullRequestReviewersRow.tsx b/desktop/src/features/projects/ui/PullRequestReviewersRow.tsx
new file mode 100644
index 0000000000..da7c4e04cb
--- /dev/null
+++ b/desktop/src/features/projects/ui/PullRequestReviewersRow.tsx
@@ -0,0 +1,228 @@
+import { Check, Search, UserPlus } from "lucide-react";
+import * as React from "react";
+import { toast } from "sonner";
+
+import { useIsArchivedPredicate } from "@/features/identity-archive/hooks";
+import type { Project, ProjectPullRequest } from "@/features/projects/hooks";
+import { useRequestProjectPullRequestReviewMutation } from "@/features/projects/pullRequestReviews";
+import { useUserSearchQuery } from "@/features/profile/hooks";
+import type { UserProfileLookup } from "@/features/profile/lib/identity";
+import type { UserSearchResult } from "@/shared/api/types";
+import { normalizePubkey, truncatePubkey } from "@/shared/lib/pubkey";
+import { Button } from "@/shared/ui/button";
+import { Input } from "@/shared/ui/input";
+import { Popover, PopoverContent, PopoverTrigger } from "@/shared/ui/popover";
+import { Tooltip, TooltipContent, TooltipTrigger } from "@/shared/ui/tooltip";
+import { UserAvatar } from "@/shared/ui/UserAvatar";
+
+function profileForPubkey(pubkey: string, profiles?: UserProfileLookup) {
+  return profiles?.[normalizePubkey(pubkey)] ?? null;
+}
+
+function labelForPubkey(pubkey: string, profiles?: UserProfileLookup) {
+  const profile = profileForPubkey(pubkey, profiles);
+  return (
+    profile?.displayName?.trim() ||
+    profile?.nip05Handle?.trim() ||
+    truncatePubkey(pubkey)
+  );
+}
+
+function reviewerSearchLabel(user: UserSearchResult) {
+  return (
+    user.displayName?.trim() ||
+    user.nip05Handle?.trim() ||
+    truncatePubkey(user.pubkey)
+  );
+}
+
+/** Reviewer status avatars and the reviewer request picker for a pull request. */
+export function PullRequestReviewersRow({
+  canRequest,
+  profiles,
+  project,
+  pullRequest,
+  signAsManagedOwner,
+}: {
+  canRequest: boolean;
+  profiles?: UserProfileLookup;
+  project: Project;
+  pullRequest: ProjectPullRequest;
+  signAsManagedOwner: boolean;
+}) {
+  const [pickerOpen, setPickerOpen] = React.useState(false);
+  const [reviewerQuery, setReviewerQuery] = React.useState("");
+  const requestInFlightRef = React.useRef(false);
+  const requestReviewMutation =
+    useRequestProjectPullRequestReviewMutation(project);
+  const deferredReviewerQuery = React.useDeferredValue(reviewerQuery.trim());
+  const requestedReviewers = React.useMemo(
+    () => new Set(pullRequest.reviewers.map(normalizePubkey)),
+    [pullRequest.reviewers],
+  );
+  const pullRequestAuthor = normalizePubkey(pullRequest.author);
+  const userSearchQuery = useUserSearchQuery(deferredReviewerQuery, {
+    allowEmpty: true,
+    enabled: canRequest && pickerOpen,
+    limit: 50,
+  });
+  const isArchivedDiscovery = useIsArchivedPredicate();
+  const candidates = React.useMemo(
+    () =>
+      (userSearchQuery.data ?? []).filter((user) => {
+        const pubkey = normalizePubkey(user.pubkey);
+        return (
+          pubkey !== pullRequestAuthor &&
+          !requestedReviewers.has(pubkey) &&
+          !isArchivedDiscovery(pubkey)
+        );
+      }),
+    [
+      isArchivedDiscovery,
+      pullRequestAuthor,
+      requestedReviewers,
+      userSearchQuery.data,
+    ],
+  );
+  const approvedBy = new Set(
+    pullRequest.approvals.map((approval) => normalizePubkey(approval.author)),
+  );
+
+  const handleRequest = React.useCallback(
+    async (pubkey: string, reviewerLabel: string) => {
+      if (requestReviewMutation.isPending || requestInFlightRef.current) return;
+      requestInFlightRef.current = true;
+      try {
+        await requestReviewMutation.mutateAsync({
+          pullRequest,
+          reviewers: [pubkey],
+          reviewerLabel,
+          signAsManagedOwner,
+        });
+        setPickerOpen(false);
+        setReviewerQuery("");
+        toast.success("Review requested.");
+      } catch (error) {
+        toast.error(
+          error instanceof Error ? error.message : "Failed to request review.",
+        );
+      } finally {
+        requestInFlightRef.current = false;
+      }
+    },
+    [pullRequest, requestReviewMutation, signAsManagedOwner],
+  );
+
+  React.useEffect(() => {
+    if (!pickerOpen) setReviewerQuery("");
+  }, [pickerOpen]);
+
+  if (pullRequest.reviewers.length === 0 && !canRequest) {
+    return null;
+  }
+
+  return (
+    <div className="flex min-w-0 flex-wrap items-center gap-1.5 text-xs text-muted-foreground">
+      {pullRequest.reviewers.map((pubkey) => {
+        const profile = profileForPubkey(pubkey, profiles);
+        const label = labelForPubkey(pubkey, profiles);
+        const hasApproved = approvedBy.has(normalizePubkey(pubkey));
+        return (
+          <Tooltip key={pubkey}>
+            <TooltipTrigger asChild>
+              <span className="relative inline-flex">
+                <UserAvatar
+                  accent={profile?.isAgent === true}
+                  avatarUrl={profile?.avatarUrl ?? null}
+                  displayName={label}
+                  size="xs"
+                />
+                {hasApproved ? (
+                  <span className="-right-1 -bottom-1 absolute flex h-3.5 w-3.5 items-center justify-center rounded-full bg-green-600 text-white ring-2 ring-background">
+                    <Check className="h-2.5 w-2.5" />
+                  </span>
+                ) : null}
+              </span>
+            </TooltipTrigger>
+            <TooltipContent>
+              {label}
+              {hasApproved ? " — approved" : " — review requested"}
+            </TooltipContent>
+          </Tooltip>
+        );
+      })}
+      {canRequest ? (
+        <Popover onOpenChange={setPickerOpen} open={pickerOpen}>
+          <PopoverTrigger asChild>
+            <Button
+              className="h-6 gap-1 px-2 text-2xs text-muted-foreground hover:text-foreground"
+              disabled={requestReviewMutation.isPending}
+              size="xs"
+              type="button"
+              variant="outline"
+            >
+              <UserPlus className="h-3 w-3" />
+              Request
+            </Button>
+          </PopoverTrigger>
+          <PopoverContent align="start" className="w-72 p-2">
+            <div className="flex items-center gap-2 border-b border-border/70 px-2 pb-2">
+              <Search className="h-3.5 w-3.5 shrink-0 text-muted-foreground" />
+              <Input
+                autoFocus
+                className="h-7 border-0 px-0 text-xs shadow-none focus-visible:ring-0"
+                data-testid="project-reviewer-search"
+                onChange={(event) => setReviewerQuery(event.target.value)}
+                placeholder="Search people and agents"
+                value={reviewerQuery}
+              />
+            </div>
+            <div className="mt-2 max-h-64 overflow-y-auto">
+              {userSearchQuery.isLoading ? (
+                <p className="px-2 py-2 text-xs text-muted-foreground">
+                  Searching…
+                </p>
+              ) : candidates.length > 0 ? (
+                candidates.map((candidate) => {
+                  const label = reviewerSearchLabel(candidate);
+                  return (
+                    <button
+                      className="flex w-full min-w-0 items-center gap-2 rounded-md px-2 py-1.5 text-left hover:bg-accent disabled:cursor-not-allowed disabled:opacity-50"
+                      data-testid={`project-reviewer-result-${candidate.pubkey}`}
+                      disabled={requestReviewMutation.isPending}
+                      key={candidate.pubkey}
+                      onClick={() => {
+                        void handleRequest(candidate.pubkey, label);
+                      }}
+                      type="button"
+                    >
+                      <UserAvatar
+                        accent={candidate.isAgent}
+                        avatarUrl={candidate.avatarUrl}
+                        displayName={label}
+                        size="xs"
+                      />
+                      <span className="min-w-0 flex-1">
+                        <span className="block truncate text-xs font-medium text-foreground">
+                          {label}
+                        </span>
+                        <span className="block truncate text-2xs text-muted-foreground">
+                          {candidate.isAgent ? "Agent · " : ""}
+                          {truncatePubkey(candidate.pubkey)}
+                        </span>
+                      </span>
+                    </button>
+                  );
+                })
+              ) : (
+                <p className="px-2 py-2 text-xs text-muted-foreground">
+                  No matching people or agents.
+                </p>
+              )}
+            </div>
+          </PopoverContent>
+        </Popover>
+      ) : null}
+    </div>
+  );
+}
diff --git a/desktop/src/features/projects/ui/projectDetailHelpers.ts b/desktop/src/features/projects/ui/projectDetailHelpers.ts
new file mode 100644
index 0000000000..b54ab04423
--- /dev/null
+++ b/desktop/src/features/projects/ui/projectDetailHelpers.ts
@@ -0,0 +1,36 @@
+import type { Project, ProjectRepoSnapshot } from "@/features/projects/hooks";
+import { normalizePubkey } from "@/shared/lib/pubkey";
+
+/** Tooltip for the push/pull sync buttons, e.g. "Pull 2 remote commits". */
+export function pushPullTitle(
+  verb: "Push" | "Pull",
+  count: number | undefined,
+  side: "local" | "remote",
+) {
+  if (!count) return `${verb} ${side} commits`;
+  return `${verb} ${count} ${side} ${count === 1 ? "commit" : "commits"}`;
+}
+
+/** Returns the normalized owner and contributor pubkeys for a project. */
+export function projectPeople(project: Project) {
+  return [
+    ...new Set(
+      [project.owner, ...project.contributors]
+        .filter(Boolean)
+        .map(normalizePubkey),
+    ),
+  ];
+}
+
+/** Reports whether a repository snapshot contains any displayable content. */
+export function snapshotHasContent(
+  snapshot: ProjectRepoSnapshot | null | undefined,
+) {
+  return Boolean(
+    snapshot &&
+      (snapshot.latestCommit ||
+        snapshot.commits.length > 0 ||
+        snapshot.files.length > 0 ||
+        snapshot.contributors.length > 0),
+  );
+}
diff --git a/desktop/src/features/projects/ui/projectListRowStyles.ts b/desktop/src/features/projects/ui/projectListRowStyles.ts
new file mode 100644
index 0000000000..97271cbcbe
--- /dev/null
+++ b/desktop/src/features/projects/ui/projectListRowStyles.ts
@@ -0,0 +1,31 @@
+/** Inbox-aligned spacing and typography for top-level Projects list rows. */
+export const PROJECT_LIST_CONTAINER_CLASS =
+  "divide-y divide-border/60 overflow-hidden rounded-xl border border-border/60 bg-card";
+
+export const PROJECT_LIST_ROW_CLASS =
+  "group relative px-3 py-3 transition-colors duration-150 hover:bg-muted/20";
+
+export const PROJECT_LIST_ROW_CONTENT_CLASS =
+  "flex min-w-0 items-start gap-2.5";
+
+export const PROJECT_LIST_ROW_TITLE_CLASS =
+  "truncate text-sm font-semibold leading-5 text-foreground";
+
+export const PROJECT_LIST_ROW_META_TEXT_CLASS =
+  "text-2xs leading-3 text-muted-foreground";
+
+export const PROJECT_LIST_ROW_META_CLASS = `flex min-w-0 flex-wrap items-center gap-x-1.5 gap-y-0.5 ${PROJECT_LIST_ROW_META_TEXT_CLASS}`;
+
+export const PROJECT_LIST_ROW_SUBTEXT_CLASS =
+  "mt-0.5 text-sm leading-5 text-muted-foreground";
+
+export const PROJECT_LIST_ROW_PREVIEW_CLASS = `line-clamp-1 ${PROJECT_LIST_ROW_SUBTEXT_CLASS}`;
+
+export const PROJECT_LIST_ROW_TRAILING_CLASS =
+  "relative z-10 ml-auto flex shrink-0 items-center gap-3";
+
+export const PROJECT_LIST_ROW_STATUS_CLASS =
+  "hidden w-20 shrink-0 text-left text-2xs leading-3 text-muted-foreground md:block";
+
+export const PROJECT_LIST_ROW_DATE_CLASS =
+  "hidden w-24 shrink-0 text-right text-xs leading-4 text-muted-foreground/70 sm:block";
diff --git a/desktop/src/features/projects/ui/projectPanelStyles.ts b/desktop/src/features/projects/ui/projectPanelStyles.ts
new file mode 100644
index 0000000000..91ff212d5c
--- /dev/null
+++ b/desktop/src/features/projects/ui/projectPanelStyles.ts
@@ -0,0 +1,3 @@
+/** Settings-aligned action button used at the right edge of panel headers. */
+export const PROJECT_PANEL_ACTION_BUTTON_CLASS =
+  "h-auto shrink-0 gap-1.5 rounded-full border-transparent bg-muted px-3 py-1.5 text-sm font-medium text-foreground shadow-none hover:bg-muted/80";
diff --git a/desktop/src/main.tsx b/desktop/src/main.tsx
index a73105a671..abc9916b3b 100644
--- a/desktop/src/main.tsx
+++ b/desktop/src/main.tsx
@@ -94,9 +94,12 @@ function renderApp() {
 }
 
 async function installE2eBridgeIfConfigured() {
-  // Keep the large E2E bridge out of the normal startup path and production
-  // bundle; only load it when tests explicitly inject an E2E config.
-  if (!(window as E2eWindow).__BUZZ_E2E__) {
+  // The mock bridge is compiled only into dev and explicit E2E builds. A
+  // pre-bootstrap global alone must never activate mock IPC in production.
+  if (
+    !(import.meta.env.DEV || import.meta.env.MODE === "e2e") ||
+    !(window as E2eWindow).__BUZZ_E2E__
+  ) {
     return;
   }
 
diff --git a/desktop/src/shared/api/projectGit.ts b/desktop/src/shared/api/projectGit.ts
index ddee6dcb53..a212623617 100644
--- a/desktop/src/shared/api/projectGit.ts
+++ b/desktop/src/shared/api/projectGit.ts
@@ -1,7 +1,9 @@
 import type {
   ProjectLocalRepository,
   ProjectLocalRepoSnapshot,
+  ProjectRepoCloneResult,
   ProjectRepoDiff,
+  ProjectRepoMergeResult,
   ProjectRepoPullResult,
   ProjectRepoPushResult,
   ProjectRepoSnapshot,
@@ -70,6 +72,7 @@ type RawProjectRepoSyncStatus = {
   remote_branch: string | null;
   remote_head: string | null;
   remote_short_head: string | null;
+  merge_base: string | null;
   ahead_count: number;
   behind_count: number;
   has_uncommitted_changes: boolean;
@@ -83,6 +86,9 @@ type RawProjectRepoSyncStatus = {
 type RawProjectRepoPushResult = {
   pushed: boolean;
   message: string;
+  branch: string;
+  commit: string;
+  merge_base: string | null;
 };
 
 type RawProjectRepoPullResult = {
@@ -273,6 +279,7 @@ function fromRawProjectRepoSyncStatus(
     remoteBranch: status.remote_branch,
     remoteHead: status.remote_head,
     remoteShortHead: status.remote_short_head,
+    mergeBase: status.merge_base,
     aheadCount: status.ahead_count,
     behindCount: status.behind_count,
     hasUncommittedChanges: status.has_uncommitted_changes,
@@ -288,7 +295,8 @@ export async function getProjectRepoSyncStatus(input: {
   reposDir?: string | null;
   projectDtag: string;
   cloneUrl: string;
-  defaultBranch?: string | null;
+  branchName?: string | null;
+  baseBranch?: string | null;
 }): Promise<ProjectRepoSyncStatus> {
   const status = await invokeTauri<RawProjectRepoSyncStatus>(
     "get_project_repo_sync_status",
@@ -296,7 +304,8 @@ export async function getProjectRepoSyncStatus(input: {
       reposDir: input.reposDir ?? null,
       projectDtag: input.projectDtag,
       cloneUrl: input.cloneUrl,
-      defaultBranch: input.defaultBranch ?? null,
+      branchName: input.branchName ?? null,
+      baseBranch: input.baseBranch ?? null,
     },
   );
   return fromRawProjectRepoSyncStatus(status);
@@ -332,7 +341,8 @@ export async function pushProjectLocalRepository(input: {
   reposDir?: string | null;
   projectDtag: string;
   cloneUrl: string;
-  defaultBranch?: string | null;
+  branchName?: string | null;
+  baseBranch?: string | null;
 }): Promise<ProjectRepoPushResult> {
   const result = await invokeTauri<RawProjectRepoPushResult>(
     "push_project_local_repository",
@@ -340,12 +350,16 @@ export async function pushProjectLocalRepository(input: {
       reposDir: input.reposDir ?? null,
       projectDtag: input.projectDtag,
       cloneUrl: input.cloneUrl,
-      defaultBranch: input.defaultBranch ?? null,
+      branchName: input.branchName ?? null,
+      baseBranch: input.baseBranch ?? null,
     },
   );
   return {
     pushed: result.pushed,
     message: result.message,
+    branch: result.branch,
+    commit: result.commit,
+    mergeBase: result.merge_base,
   };
 }
 
@@ -353,7 +367,7 @@ export async function pullProjectLocalRepository(input: {
   reposDir?: string | null;
   projectDtag: string;
   cloneUrl: string;
-  defaultBranch?: string | null;
+  branchName?: string | null;
 }): Promise<ProjectRepoPullResult> {
   const result = await invokeTauri<RawProjectRepoPullResult>(
     "pull_project_local_repository",
@@ -361,7 +375,7 @@ export async function pullProjectLocalRepository(input: {
       reposDir: input.reposDir ?? null,
       projectDtag: input.projectDtag,
       cloneUrl: input.cloneUrl,
-      defaultBranch: input.defaultBranch ?? null,
+      branchName: input.branchName ?? null,
     },
   );
   return {
@@ -369,3 +383,71 @@ export async function pullProjectLocalRepository(input: {
     message: result.message,
   };
 }
+
+export async function cloneProjectRepository(input: {
+  reposDir?: string | null;
+  projectDtag: string;
+  cloneUrl: string;
+  defaultBranch?: string | null;
+}): Promise<ProjectRepoCloneResult> {
+  return invokeTauri<ProjectRepoCloneResult>("clone_project_repository", {
+    reposDir: input.reposDir ?? null,
+    projectDtag: input.projectDtag,
+    cloneUrl: input.cloneUrl,
+    defaultBranch: input.defaultBranch ?? null,
+  });
+}
+
+type RawProjectRepoMergeResult = {
+  message: string;
+  merge_commit: string;
+  status_event: string;
+  status_publication_error: string | null;
+};
+
+export async function mergeProjectPullRequest(input: {
+  targetCloneUrl: string;
+  sourceCloneUrl: string;
+  targetOwner: string;
+  repoAddress: string;
+  pullRequestId: string;
+  pullRequestAuthor: string;
+  statusCreatedAt: number;
+  targetBranch: string;
+  sourceBranch: string;
+  expectedCommit: string;
+}): Promise<ProjectRepoMergeResult> {
+  const result = await invokeTauri<RawProjectRepoMergeResult>(
+    "merge_project_pull_request",
+    {
+      input,
+    },
+  );
+  return {
+    message: result.message,
+    mergeCommit: result.merge_commit,
+    statusEvent: result.status_event,
+    statusPublicationError: result.status_publication_error,
+  };
+}
+
+export async function signProjectPullRequestReviewRequest(input: {
+  targetOwner: string;
+  repoAddress: string;
+  pullRequestId: string;
+  reviewers: string[];
+  reviewerLabel: string;
+}): Promise<void> {
+  await invokeTauri<void>("sign_project_pull_request_review_request", {
+    input,
+  });
+}
+
+export async function publishProjectPullRequestMergedStatus(input: {
+  targetOwner: string;
+  statusEvent: string;
+}): Promise<void> {
+  await invokeTauri<void>("publish_project_pull_request_merged_status", {
+    input,
+  });
+}
diff --git a/desktop/src/shared/api/projectGitTypes.ts b/desktop/src/shared/api/projectGitTypes.ts
index 35bd6f9850..fb9cd03f3c 100644
--- a/desktop/src/shared/api/projectGitTypes.ts
+++ b/desktop/src/shared/api/projectGitTypes.ts
@@ -63,6 +63,7 @@ export type ProjectRepoSyncStatus = {
   remoteBranch: string | null;
   remoteHead: string | null;
   remoteShortHead: string | null;
+  mergeBase: string | null;
   aheadCount: number;
   behindCount: number;
   hasUncommittedChanges: boolean;
@@ -76,9 +77,25 @@ export type ProjectRepoSyncStatus = {
 export type ProjectRepoPushResult = {
   pushed: boolean;
   message: string;
+  branch: string;
+  commit: string;
+  mergeBase: string | null;
 };
 
 export type ProjectRepoPullResult = {
   pulled: boolean;
   message: string;
 };
+
+export type ProjectRepoCloneResult = {
+  path: string;
+  cloned: boolean;
+  message: string;
+};
+
+export type ProjectRepoMergeResult = {
+  message: string;
+  mergeCommit: string;
+  statusEvent: string;
+  statusPublicationError: string | null;
+};
diff --git a/desktop/src/shared/api/types.ts b/desktop/src/shared/api/types.ts
index 85ff218e83..2bac1c18cd 100644
--- a/desktop/src/shared/api/types.ts
+++ b/desktop/src/shared/api/types.ts
@@ -192,9 +192,11 @@ export type {
   ProjectLocalRepoSnapshot,
   ProjectRepoCommit,
   ProjectRepoContributor,
+  ProjectRepoCloneResult,
   ProjectRepoDiff,
   ProjectRepoDiffFile,
   ProjectRepoFile,
+  ProjectRepoMergeResult,
   ProjectRepoPullResult,
   ProjectRepoPushResult,
   ProjectRepoSnapshot,
diff --git a/desktop/src/shared/styles/globals/scrollbars.css b/desktop/src/shared/styles/globals/scrollbars.css
index 8a19fa560e..4614967745 100644
--- a/desktop/src/shared/styles/globals/scrollbars.css
+++ b/desktop/src/shared/styles/globals/scrollbars.css
@@ -45,6 +45,10 @@
  * set, engines ignore the `::-webkit-scrollbar` pseudo styles and fall back
  * to overlay scrollbars, which reintroduces the bug.
  */
+.buzz-content-scrollbar {
+  scrollbar-gutter: stable;
+}
+
 .buzz-content-scrollbar::-webkit-scrollbar {
   height: 10px;
   width: 10px;
diff --git a/desktop/src/testing/e2eBridge.ts b/desktop/src/testing/e2eBridge.ts
index 67bcb3f96f..012d600d7d 100644
--- a/desktop/src/testing/e2eBridge.ts
+++ b/desktop/src/testing/e2eBridge.ts
@@ -38,6 +38,7 @@ import {
   KIND_REPO_ANNOUNCEMENT,
   KIND_STREAM_MESSAGE_EDIT,
   KIND_SYSTEM_MESSAGE,
+  KIND_TEXT_NOTE,
   KIND_USER_STATUS,
 } from "@/shared/constants/kinds";
 import type {
@@ -908,6 +909,28 @@ declare global {
       kind: number;
       tags: string[][];
     }>;
+    /** Project event kinds rejected once, in order, to exercise retry flows. */
+    __BUZZ_E2E_REJECT_PROJECT_EVENT_KINDS__?: number[];
+    /** Overrides the first mock repository owner for delegated-owner tests. */
+    __BUZZ_E2E_PROJECT_OWNER_OVERRIDE__?: string;
+    __BUZZ_E2E_PROJECT_REPO_SYNC_STATUS__?: {
+      local_path: string | null;
+      local_branch: string | null;
+      local_head: string | null;
+      local_short_head: string | null;
+      remote_branch: string | null;
+      remote_head: string | null;
+      remote_short_head: string | null;
+      merge_base: string | null;
+      ahead_count: number;
+      behind_count: number;
+      has_uncommitted_changes: boolean;
+      has_untracked_files: boolean;
+      can_push: boolean;
+      push_block_reason: string | null;
+      can_pull: boolean;
+      pull_block_reason: string | null;
+    };
     __BUZZ_E2E_SET_RELAY_CONNECTION_STATE__?: (state: ConnectionState) => void;
     __BUZZ_E2E_GET_RELAY_CONNECTION_STATE__?: () => ConnectionState;
     __BUZZ_E2E_SET_STALL_WEBSOCKET_SENDS__?: (stall: boolean) => void;
@@ -4683,7 +4706,11 @@ function buildMockProjectEvents(): RelayEvent[] {
   const historyDays = 26 * 7;
 
   for (const [projectIndex, seed] of MOCK_PROJECT_SEEDS.entries()) {
-    const repoAddress = `${KIND_REPO_ANNOUNCEMENT}:${seed.owner}:${seed.dtag}`;
+    const owner =
+      projectIndex === 0
+        ? (window.__BUZZ_E2E_PROJECT_OWNER_OVERRIDE__ ?? seed.owner)
+        : seed.owner;
+    const repoAddress = `${KIND_REPO_ANNOUNCEMENT}:${owner}:${seed.dtag}`;
     const authors = [seed.owner, ...seed.contributors];
     const random = mulberry32(projectIndex + 1);
 
@@ -4695,10 +4722,10 @@ function buildMockProjectEvents(): RelayEvent[] {
           ["d", seed.dtag],
           ["name", seed.name],
           ["description", seed.description],
-          ["clone", `https://relay.example.com/git/${seed.dtag}.git`],
+          ["clone", `https://relay.example.com/git/${owner}/${seed.dtag}`],
           ...seed.contributors.map((pubkey) => ["p", pubkey]),
         ],
-        seed.owner,
+        owner,
         now - (historyDays + 30 + projectIndex) * daySeconds,
         `mock-project-${seed.dtag}`.replace(/[^a-zA-Z0-9]/g, ""),
       ),
@@ -4731,6 +4758,15 @@ function buildMockProjectEvents(): RelayEvent[] {
           ["a", repoAddress],
           ["subject", subject],
           ...(kind === KIND_GIT_ISSUE ? [] : [["c", commitHash]]),
+          ...(kind === KIND_GIT_PULL_REQUEST
+            ? [
+                ["branch-name", `feature/mock-${dayOffset}-${index}`],
+                [
+                  "clone",
+                  `https://relay.example.com/git/${owner}/${seed.dtag}`,
+                ],
+              ]
+            : []),
         ];
 
         events.push(createMockEvent(kind, subject, tags, author, createdAt));
@@ -8456,6 +8492,31 @@ function sendToMockSocket(args: {
     }
 
     if (isMockProjectScopedEvent(event)) {
+      if (event.pubkey !== DEFAULT_MOCK_IDENTITY.pubkey) {
+        sendWsText(socket.handler, [
+          "OK",
+          event.id,
+          false,
+          "invalid: event pubkey does not match authenticated identity",
+        ]);
+        return;
+      }
+      const rejectionIndex =
+        window.__BUZZ_E2E_REJECT_PROJECT_EVENT_KINDS__?.indexOf(event.kind) ??
+        -1;
+      if (rejectionIndex >= 0) {
+        window.__BUZZ_E2E_REJECT_PROJECT_EVENT_KINDS__?.splice(
+          rejectionIndex,
+          1,
+        );
+        sendWsText(socket.handler, [
+          "OK",
+          event.id,
+          false,
+          "mock project event rejection",
+        ]);
+        return;
+      }
       getMockProjectEventStore().push(event);
       sendWsText(socket.handler, ["OK", event.id, true, ""]);
       return;
@@ -9086,35 +9147,168 @@ export function maybeInstallE2eTauriMocks() {
       case "get_project_local_repo_diff":
         return null;
       case "get_project_repo_sync_status":
-        return {
-          local_path: null,
-          local_branch: null,
-          local_head: null,
-          local_short_head: null,
-          remote_branch: "main",
-          remote_head: "0123456789abcdef0123456789abcdef01234567",
-          remote_short_head: "0123456",
-          ahead_count: 0,
-          behind_count: 0,
-          has_uncommitted_changes: false,
-          has_untracked_files: false,
-          can_push: false,
-          push_block_reason: "No local checkout found.",
-          can_pull: false,
-          pull_block_reason: "No local checkout found.",
-        };
+        return (
+          window.__BUZZ_E2E_PROJECT_REPO_SYNC_STATUS__ ?? {
+            local_path: null,
+            local_branch: null,
+            local_head: null,
+            local_short_head: null,
+            remote_branch: "main",
+            remote_head: "0123456789abcdef0123456789abcdef01234567",
+            remote_short_head: "0123456",
+            merge_base: "0123456789abcdef0123456789abcdef01234567",
+            ahead_count: 0,
+            behind_count: 0,
+            has_uncommitted_changes: false,
+            has_untracked_files: false,
+            can_push: false,
+            push_block_reason: "No local checkout found.",
+            can_pull: false,
+            pull_block_reason: "No local checkout found.",
+          }
+        );
       case "list_project_local_repositories":
         return [];
-      case "push_project_local_repository":
+      case "push_project_local_repository": {
+        const input = payload as { branchName?: string | null };
+        const status = window.__BUZZ_E2E_PROJECT_REPO_SYNC_STATUS__;
+        const branch = input.branchName ?? status?.remote_branch ?? "main";
+        const commit =
+          status?.local_head ?? "0123456789abcdef0123456789abcdef01234567";
+        if (status) {
+          status.remote_branch = branch;
+          status.remote_head = commit;
+          status.remote_short_head = commit.slice(0, 7);
+          status.ahead_count = 0;
+          status.can_push = false;
+          status.push_block_reason = "Local branch is already pushed.";
+        }
         return {
           pushed: true,
-          message: "Pushed main to remote.",
+          message: `Pushed ${branch} to remote.`,
+          branch,
+          commit,
+          merge_base:
+            status?.merge_base ?? "0123456789abcdef0123456789abcdef01234567",
         };
+      }
       case "pull_project_local_repository":
         return {
           pulled: true,
           message: "Pulled main from remote.",
         };
+      case "clone_project_repository":
+        return {
+          path: "/tmp/buzz/REPOS/mock-project",
+          cloned: true,
+          message: "Cloned repository.",
+        };
+      case "sign_project_pull_request_review_request": {
+        const { input } = payload as {
+          input: {
+            pullRequestId: string;
+            repoAddress: string;
+            reviewerLabel: string;
+            reviewers: string[];
+            targetOwner: string;
+          };
+        };
+        const event = createMockEvent(
+          KIND_TEXT_NOTE,
+          `Requested a review from ${input.reviewerLabel}`,
+          [
+            ["e", input.pullRequestId, "", "root"],
+            ["a", input.repoAddress],
+            ...input.reviewers.map((reviewer) => ["p", reviewer]),
+            ["t", "review-request"],
+          ],
+          input.targetOwner,
+        );
+        window.__BUZZ_E2E_SIGNED_EVENTS__?.push({
+          content: event.content,
+          kind: event.kind,
+          tags: event.tags,
+        });
+        getMockProjectEventStore().push(event);
+        return null;
+      }
+      case "publish_project_pull_request_merged_status": {
+        const { input } = payload as {
+          input: { statusEvent: string; targetOwner: string };
+        };
+        const event = JSON.parse(input.statusEvent) as RelayEvent;
+        if (event.pubkey !== input.targetOwner) {
+          throw new Error("mock merged status owner mismatch");
+        }
+        getMockProjectEventStore().push(event);
+        return null;
+      }
+      case "merge_project_pull_request": {
+        const { input } = payload as {
+          input: {
+            expectedCommit: string;
+            pullRequestAuthor: string;
+            pullRequestId: string;
+            repoAddress: string;
+            sourceBranch: string;
+            statusCreatedAt: number;
+            targetBranch: string;
+            targetOwner: string;
+          };
+        };
+        const normalizedTargetOwner = input.targetOwner.toLowerCase();
+        const canSignAsOwner =
+          (identity?.pubkey ?? MOCK_IDENTITY_PUBKEY).toLowerCase() ===
+            normalizedTargetOwner ||
+          mockManagedAgents.some(
+            (agent) => agent.pubkey.toLowerCase() === normalizedTargetOwner,
+          );
+        if (!canSignAsOwner) {
+          throw new Error(
+            "Only the repository owner or the owner of its managed agent can merge pull requests.",
+          );
+        }
+        const mergeCommit = "abcdef0123456789abcdef0123456789abcdef01";
+        const statusEvent = createMockEvent(
+          KIND_GIT_STATUS_MERGED,
+          "",
+          [
+            ["e", input.pullRequestId, "", "root"],
+            ["a", input.repoAddress],
+            ["p", input.targetOwner],
+            ["p", input.pullRequestAuthor],
+            ["merge-commit", mergeCommit],
+            ["r", mergeCommit],
+          ],
+          input.targetOwner,
+          input.statusCreatedAt,
+        );
+        window.__BUZZ_E2E_SIGNED_EVENTS__?.push({
+          content: statusEvent.content,
+          kind: statusEvent.kind,
+          tags: statusEvent.tags,
+        });
+        const rejectionIndex =
+          window.__BUZZ_E2E_REJECT_PROJECT_EVENT_KINDS__?.indexOf(
+            statusEvent.kind,
+          ) ?? -1;
+        let statusPublicationError: string | null = null;
+        if (rejectionIndex >= 0) {
+          window.__BUZZ_E2E_REJECT_PROJECT_EVENT_KINDS__?.splice(
+            rejectionIndex,
+            1,
+          );
+          statusPublicationError = "mock project event rejection";
+        } else {
+          getMockProjectEventStore().push(statusEvent);
+        }
+        return {
+          message: "Merged feature into main.",
+          merge_commit: mergeCommit,
+          status_event: JSON.stringify(statusEvent),
+          status_publication_error: statusPublicationError,
+        };
+      }
       case "get_relay_ws_url":
         return getRelayWsUrl(activeConfig);
       case "get_default_relay_url":
diff --git a/desktop/tests/e2e/project-commit-detail.spec.ts b/desktop/tests/e2e/project-commit-detail.spec.ts
index 0b55554373..8f209f7afe 100644
--- a/desktop/tests/e2e/project-commit-detail.spec.ts
+++ b/desktop/tests/e2e/project-commit-detail.spec.ts
@@ -4,6 +4,7 @@ import { waitForAnimations } from "../helpers/animations";
 import { installMockBridge } from "../helpers/bridge";
 
 const SHOTS = "test-results/project-commit-detail";
+const ALIGNMENT_TOLERANCE_PX = 2;
 
 // The projects surface is a preview feature — opt in before the app mounts.
 // Must run before installMockBridge so React reads the override on mount.
@@ -16,6 +17,122 @@ async function enableProjectsFeature(page: import("@playwright/test").Page) {
   });
 }
 
+test("top-level project lists align dates and overflow actions", async ({
+  page,
+}) => {
+  await enableProjectsFeature(page);
+  await page.addInitScript(() => {
+    window.localStorage.setItem("buzz.projects.viewMode", "list");
+  });
+  await installMockBridge(page);
+  await page.goto("/", { waitUntil: "domcontentloaded" });
+  await page.getByTestId("open-projects-view").click();
+
+  async function trailingPositions(row: import("@playwright/test").Locator) {
+    await waitForAnimations(page);
+    const date = row.getByTestId("projects-row-date");
+    const menu = row.getByRole("button", { name: /More options for/ });
+    await expect(date).toBeVisible();
+    await expect(menu).toBeVisible();
+    const dateBox = await date.boundingBox();
+    const menuBox = await menu.boundingBox();
+    expect(dateBox).not.toBeNull();
+    expect(menuBox).not.toBeNull();
+    return { dateX: dateBox?.x ?? 0, menuX: menuBox?.x ?? 0 };
+  }
+
+  await page.getByRole("button", { name: "Repositories", exact: true }).click();
+  await page.getByRole("button", { name: "Filter repositories" }).click();
+  await expect(
+    page.getByRole("menuitem", { name: "My Repositories" }),
+  ).toBeVisible();
+  await expect(page.getByRole("menuitem", { name: "Local" })).toBeVisible();
+  await page.keyboard.press("Escape");
+  const repositoryPositions = await trailingPositions(
+    page.locator('[data-testid^="project-row-"]').first(),
+  );
+
+  await page
+    .getByRole("button", { name: "Pull Requests", exact: true })
+    .click();
+  await page.getByRole("button", { name: "Filter pull requests" }).click();
+  await expect(
+    page.getByRole("menuitem", { name: "My Pull Requests" }),
+  ).toBeVisible();
+  await page.keyboard.press("Escape");
+  await page.getByTestId("projects-create-menu").hover();
+  await expect(
+    page.getByRole("menuitem", { name: "Repository" }),
+  ).toBeVisible();
+  await expect(page.getByRole("menuitem", { name: "Issue" })).toBeVisible();
+  await page
+    .getByRole("menuitem", { name: "Pull Request", exact: true })
+    .click();
+  await expect(page.getByTestId("create-pull-request-dialog")).toBeVisible();
+  await expect(
+    page.getByTestId("create-pull-request-repository"),
+  ).toBeVisible();
+  await page.keyboard.press("Escape");
+  await page.getByTestId("projects-create-menu").hover();
+  await page.getByRole("menuitem", { name: "Issue" }).click();
+  await expect(page.getByTestId("create-issue-repository")).toBeVisible();
+  await page.keyboard.press("Escape");
+  const pullRequestRow = page
+    .locator('[data-testid^="projects-pr-row-"]')
+    .first();
+  const pullRequestPositions = await trailingPositions(pullRequestRow);
+  await pullRequestRow
+    .getByRole("button", { name: /More options for/ })
+    .click();
+  await expect(
+    page.getByRole("menuitem", { name: /Review PR|View (draft|merge|closed)/ }),
+  ).toBeVisible();
+  await page.keyboard.press("Escape");
+
+  await page.getByRole("button", { name: "Issues", exact: true }).click();
+  await page.getByRole("button", { name: "Filter issues" }).click();
+  await expect(page.getByRole("menuitem", { name: "My Issues" })).toBeVisible();
+  await page.keyboard.press("Escape");
+  const issueRow = page.locator('[data-testid^="projects-issue-row-"]').first();
+  const issuePositions = await trailingPositions(issueRow);
+
+  expect(
+    Math.abs(pullRequestPositions.dateX - repositoryPositions.dateX),
+  ).toBeLessThanOrEqual(ALIGNMENT_TOLERANCE_PX);
+  expect(
+    Math.abs(pullRequestPositions.menuX - repositoryPositions.menuX),
+  ).toBeLessThanOrEqual(ALIGNMENT_TOLERANCE_PX);
+  expect(
+    Math.abs(issuePositions.dateX - repositoryPositions.dateX),
+  ).toBeLessThanOrEqual(ALIGNMENT_TOLERANCE_PX);
+  expect(
+    Math.abs(issuePositions.menuX - repositoryPositions.menuX),
+  ).toBeLessThanOrEqual(ALIGNMENT_TOLERANCE_PX);
+
+  await page.setViewportSize({ height: 720, width: 900 });
+  await page.getByRole("button", { name: "Repositories", exact: true }).click();
+  const responsiveRepositoryRow = page
+    .locator('[data-testid^="project-row-"]')
+    .first();
+  await expect(
+    responsiveRepositoryRow.getByTestId("projects-row-summary"),
+  ).toBeHidden();
+  await expect(
+    responsiveRepositoryRow.getByTestId("projects-row-people"),
+  ).toBeHidden();
+  await expect(
+    responsiveRepositoryRow.getByTestId("projects-row-date"),
+  ).toBeVisible();
+  await expect(
+    responsiveRepositoryRow.getByRole("button", { name: /More options for/ }),
+  ).toBeVisible();
+  expect(
+    await responsiveRepositoryRow.evaluate(
+      (row) => row.scrollWidth <= row.clientWidth,
+    ),
+  ).toBe(true);
+});
+
 test("commit detail opens from the commits feed with a diff", async ({
   page,
 }) => {
@@ -43,8 +160,10 @@ test("commit detail opens from the commits feed with a diff", async ({
   const commitRows = page.getByTestId("project-activity-feed-item");
   await expect(commitRows.first()).toBeVisible({ timeout: 10_000 });
 
-  // GitHub-style feed: commits grouped under a date header with a hash cell.
-  await expect(page.getByText(/^Commits on /).first()).toBeVisible();
+  // Commits share the rounded list structure used by issues and pull requests.
+  await expect(
+    page.getByRole("heading", { name: "Commits", exact: true }),
+  ).toBeVisible();
   await waitForAnimations(page);
   await page.screenshot({
     fullPage: false,
@@ -136,7 +255,7 @@ test("pull request and issue feeds share the commit row structure", async ({
   await projectEntry.click();
 
   // PR rows use the shared feed row: title button + #id cluster cell.
-  await page.getByRole("tab", { name: "PRs" }).click();
+  await page.getByRole("tab", { name: "Pull Request" }).click();
   const prRows = page.getByTestId("project-pull-request-row");
   await expect(prRows.first()).toBeVisible({ timeout: 10_000 });
   await expect(
@@ -149,12 +268,12 @@ test("pull request and issue feeds share the commit row structure", async ({
   await prRows.first().getByRole("button", { name: /^#/ }).click();
   await expect(
     page.getByRole("navigation", { name: "Project breadcrumb" }),
-  ).toContainText("PRs");
+  ).toContainText("Pull Request");
 
   // Step back to the feed so the community tabs are available again.
   await page
     .getByRole("navigation", { name: "Project breadcrumb" })
-    .getByRole("button", { name: "PRs", exact: true })
+    .getByRole("button", { name: "Pull Request", exact: true })
     .click();
   await expect(prRows.first()).toBeVisible();
 
diff --git a/desktop/tests/e2e/project-pr-review.spec.ts b/desktop/tests/e2e/project-pr-review.spec.ts
index e527407b8f..b7a832fb25 100644
--- a/desktop/tests/e2e/project-pr-review.spec.ts
+++ b/desktop/tests/e2e/project-pr-review.spec.ts
@@ -1,9 +1,11 @@
 import { expect, test } from "@playwright/test";
 
 import { waitForAnimations } from "../helpers/animations";
-import { installMockBridge } from "../helpers/bridge";
+import { installMockBridge, TEST_IDENTITIES } from "../helpers/bridge";
 
 const SHOTS = "test-results/project-pr-review";
+const REVIEWER_AGENT_PUBKEY = "a".repeat(64);
+const DEFAULT_MOCK_PUBKEY = "deadbeef".repeat(8);
 
 // The projects surface is a preview feature — opt in before the app mounts.
 // Must run before installMockBridge so React reads the override on mount.
@@ -16,20 +18,10 @@ async function enableProjectsFeature(page: import("@playwright/test").Page) {
   });
 }
 
-test("PR creator/owner can toggle draft, request reviews, and approve", async ({
-  page,
-}) => {
-  await enableProjectsFeature(page);
-  await installMockBridge(page);
+async function openBuzzProject(page: import("@playwright/test").Page) {
   await page.goto("/", { waitUntil: "domcontentloaded" });
   await page.getByTestId("open-projects-view").click();
-
-  // The overview no longer lists repository cards — switch to the
-  // Repositories filter to reveal the project cards/rows.
   await page.getByRole("button", { name: "Repositories", exact: true }).click();
-
-  // The "buzz" mock project is owned by the viewer, so status changes and
-  // review requests are always permitted regardless of who authored the PR.
   const projectEntry = page
     .locator(
       '[data-testid="project-card-buzz"], [data-testid="project-row-buzz"]',
@@ -37,8 +29,19 @@ test("PR creator/owner can toggle draft, request reviews, and approve", async ({
     .first();
   await expect(projectEntry).toBeVisible({ timeout: 10_000 });
   await projectEntry.click();
+}
 
-  await page.getByRole("tab", { name: "PRs" }).click();
+test("PR creator/owner can toggle draft, request reviews, and approve", async ({
+  page,
+}) => {
+  await enableProjectsFeature(page);
+  await page.addInitScript(() => {
+    window.__BUZZ_E2E_REJECT_PROJECT_EVENT_KINDS__ = [1631];
+  });
+  await installMockBridge(page);
+  await openBuzzProject(page);
+
+  await page.getByRole("tab", { name: "Pull Request" }).click();
   const prRows = page.getByTestId("project-pull-request-row");
   await expect(prRows.first()).toBeVisible({ timeout: 10_000 });
 
@@ -60,9 +63,29 @@ test("PR creator/owner can toggle draft, request reviews, and approve", async ({
   await expect(approve).toBeVisible();
 
   // Request a review from bob via the reviewers dropdown.
-  await page.getByRole("button", { name: "Request" }).click();
-  await page.getByRole("menuitem", { name: "bob" }).click();
+  await page.getByRole("button", { name: "Request", exact: true }).click();
+  await page.getByTestId("project-reviewer-search").fill("bob");
+  await page
+    .getByTestId(`project-reviewer-result-${TEST_IDENTITIES.bob.pubkey}`)
+    .evaluate((button) => {
+      button.click();
+      button.click();
+    });
   await expect(page.getByText("Review requested.")).toBeVisible();
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () =>
+          window.__BUZZ_E2E_SIGNED_EVENTS__?.filter(
+            (event) =>
+              event.kind === 1 &&
+              event.tags.some(
+                (tag) => tag[0] === "t" && tag[1] === "review-request",
+              ),
+          ).length ?? 0,
+      ),
+    )
+    .toBe(1);
   // The requested reviewer appears in the reviewers row and the timeline.
   await expect(page.getByText("Requested a review from bob")).toBeVisible({
     timeout: 10_000,
@@ -112,4 +135,362 @@ test("PR creator/owner can toggle draft, request reviews, and approve", async ({
   await expect(
     page.getByRole("button", { name: "Convert to draft" }),
   ).toBeVisible({ timeout: 10_000 });
+
+  await page.getByRole("button", { name: "Merge", exact: true }).click();
+  await expect(page.getByTestId("merge-pull-request-confirm")).toBeVisible();
+  await page.getByTestId("merge-pull-request-confirm-button").click();
+  await expect(page.getByText("Merged feature into main.")).toBeVisible();
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () =>
+          window.__BUZZ_E2E_SIGNED_EVENTS__?.filter(
+            (event) => event.kind === 1631,
+          ).length ?? 0,
+      ),
+    )
+    .toBe(1);
+  await expect(
+    page.getByRole("button", {
+      name: "Publish merged status",
+      exact: true,
+    }),
+  ).toBeVisible();
+  await page
+    .getByRole("button", {
+      name: "Publish merged status",
+      exact: true,
+    })
+    .click();
+  await expect(
+    page.getByText("Published merged pull request status."),
+  ).toBeVisible();
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () =>
+          window.__BUZZ_E2E_SIGNED_EVENTS__?.filter(
+            (event) => event.kind === 1631,
+          ).length ?? 0,
+      ),
+    )
+    .toBe(1);
+  const mergedEvent = await page.evaluate(() =>
+    window.__BUZZ_E2E_SIGNED_EVENTS__
+      ?.filter((event) => event.kind === 1631)
+      .at(-1),
+  );
+  expect(mergedEvent?.tags).toContainEqual([
+    "merge-commit",
+    "abcdef0123456789abcdef0123456789abcdef01",
+  ]);
+  expect(mergedEvent?.tags.some((tag) => tag[0] === "e")).toBe(true);
+  const mergeCommandCount = await page.evaluate(
+    () =>
+      window.__BUZZ_E2E_COMMANDS__?.filter(
+        (command) => command === "merge_project_pull_request",
+      ).length ?? 0,
+  );
+  expect(mergeCommandCount).toBe(1);
+  const mergePayload = await page.evaluate(() =>
+    window.__BUZZ_E2E_COMMAND_PAYLOADS__?.find(
+      (entry) => entry.command === "merge_project_pull_request",
+    ),
+  );
+  expect(mergePayload?.payload).toMatchObject({
+    input: {
+      expectedCommit: expect.any(String),
+      sourceBranch: expect.any(String),
+      targetBranch: "main",
+      targetOwner: DEFAULT_MOCK_PUBKEY,
+    },
+  });
+});
+
+test("managed agent repository owner can merge", async ({ page }) => {
+  await enableProjectsFeature(page);
+  await page.addInitScript((owner) => {
+    window.__BUZZ_E2E_PROJECT_OWNER_OVERRIDE__ = owner;
+  }, TEST_IDENTITIES.alice.pubkey);
+  await installMockBridge(page, {
+    managedAgents: [
+      {
+        pubkey: TEST_IDENTITIES.alice.pubkey,
+        name: "Brain",
+      },
+      {
+        pubkey: REVIEWER_AGENT_PUBKEY,
+        name: "Reviewer Bot",
+      },
+    ],
+  });
+  await openBuzzProject(page);
+
+  await page.getByRole("tab", { name: "Pull Request" }).click();
+  const agentRow = page
+    .getByTestId("project-pull-request-row")
+    .filter({ hasText: "Brain" })
+    .first();
+  await expect(agentRow).toBeVisible({ timeout: 10_000 });
+  await agentRow.getByRole("button", { name: /^#/ }).click();
+  await page.getByRole("button", { name: "Request", exact: true }).click();
+  await page.getByTestId("project-reviewer-search").fill("Reviewer Bot");
+  await page
+    .getByTestId(`project-reviewer-result-${REVIEWER_AGENT_PUBKEY}`)
+    .click();
+  await expect(page.getByText("Review requested.")).toBeVisible();
+  const reviewRequestPayload = await page.evaluate(() =>
+    window.__BUZZ_E2E_COMMAND_PAYLOADS__?.find(
+      (entry) => entry.command === "sign_project_pull_request_review_request",
+    ),
+  );
+  expect(reviewRequestPayload?.payload).toMatchObject({
+    input: {
+      reviewers: [REVIEWER_AGENT_PUBKEY],
+      targetOwner: TEST_IDENTITIES.alice.pubkey,
+    },
+  });
+  await page.getByRole("button", { name: "Merge", exact: true }).click();
+  await page.getByTestId("merge-pull-request-confirm-button").click();
+  await expect(page.getByText("Merged feature into main.")).toBeVisible();
+
+  const mergePayload = await page.evaluate(() =>
+    window.__BUZZ_E2E_COMMAND_PAYLOADS__?.find(
+      (entry) => entry.command === "merge_project_pull_request",
+    ),
+  );
+  expect(mergePayload?.payload).toMatchObject({
+    input: {
+      expectedCommit: expect.any(String),
+      sourceBranch: expect.any(String),
+      targetBranch: "main",
+      targetOwner: TEST_IDENTITIES.alice.pubkey,
+    },
+  });
+});
+
+test("viewer without repository ownership cannot merge", async ({ page }) => {
+  await enableProjectsFeature(page);
+  await page.addInitScript((owner) => {
+    window.__BUZZ_E2E_PROJECT_OWNER_OVERRIDE__ = owner;
+  }, TEST_IDENTITIES.alice.pubkey);
+  await installMockBridge(page, {
+    managedAgents: [
+      {
+        pubkey: REVIEWER_AGENT_PUBKEY,
+        name: "Reviewer Bot",
+      },
+    ],
+  });
+  await openBuzzProject(page);
+
+  await page.getByRole("tab", { name: "Pull Request" }).click();
+  const prRow = page.getByTestId("project-pull-request-row").first();
+  await expect(prRow).toBeVisible({ timeout: 10_000 });
+  await prRow.getByRole("button", { name: /^#/ }).click();
+
+  await expect(
+    page.getByRole("button", { name: "Merge", exact: true }),
+  ).toHaveCount(0);
+  const mergeCommandCount = await page.evaluate(
+    () =>
+      window.__BUZZ_E2E_COMMANDS__?.filter(
+        (command) => command === "merge_project_pull_request",
+      ).length ?? 0,
+  );
+  expect(mergeCommandCount).toBe(0);
+
+  const authorizationError = await page.evaluate(async (targetOwner) => {
+    try {
+      await window.__BUZZ_E2E_INVOKE_MOCK_COMMAND__?.(
+        "merge_project_pull_request",
+        {
+          input: {
+            expectedCommit: "1".repeat(40),
+            pullRequestAuthor: "2".repeat(64),
+            pullRequestId: "3".repeat(64),
+            repoAddress: `30617:${targetOwner}:buzz`,
+            sourceBranch: "feature/untrusted",
+            statusCreatedAt: 1,
+            targetBranch: "main",
+            targetOwner,
+          },
+        },
+      );
+      return null;
+    } catch (error) {
+      return error instanceof Error ? error.message : String(error);
+    }
+  }, TEST_IDENTITIES.alice.pubkey);
+  expect(authorizationError).toContain(
+    "Only the repository owner or the owner of its managed agent",
+  );
+});
+
+test("project without a checkout can be cloned", async ({ page }) => {
+  await enableProjectsFeature(page);
+  await installMockBridge(page);
+  await openBuzzProject(page);
+
+  await page.getByRole("button", { name: "Clone", exact: true }).click();
+  await expect(page.getByText("Cloned repository.")).toBeVisible();
+  const commands = await page.evaluate(
+    () => window.__BUZZ_E2E_COMMANDS__ ?? [],
+  );
+  expect(commands).toContain("clone_project_repository");
+});
+
+test("pushed local branch can open a pull request", async ({ page }) => {
+  await enableProjectsFeature(page);
+  await page.addInitScript(() => {
+    const commit = "1234567890abcdef1234567890abcdef12345678";
+    window.__BUZZ_E2E_PROJECT_REPO_SYNC_STATUS__ = {
+      local_path: "/tmp/buzz/REPOS/buzz",
+      local_branch: "feature/projects-workflow",
+      local_head: commit,
+      local_short_head: commit.slice(0, 7),
+      remote_branch: "feature/projects-workflow",
+      remote_head: commit,
+      remote_short_head: commit.slice(0, 7),
+      merge_base: "0123456789abcdef0123456789abcdef01234567",
+      ahead_count: 0,
+      behind_count: 0,
+      has_uncommitted_changes: false,
+      has_untracked_files: false,
+      can_push: false,
+      push_block_reason: "Local branch is already pushed.",
+      can_pull: false,
+      pull_block_reason: "Local branch is up to date.",
+    };
+    window.__BUZZ_E2E_REJECT_PROJECT_EVENT_KINDS__ = [1619];
+  });
+  await installMockBridge(page);
+  await openBuzzProject(page);
+
+  await page.getByRole("button", { name: /main/ }).click();
+  await page
+    .getByRole("menuitemradio", { name: "feature/projects-workflow" })
+    .click();
+  await page.getByRole("tab", { name: "Pull Request", exact: true }).click();
+  await page.getByRole("button", { name: "Pull Request", exact: true }).click();
+  await expect(page.getByTestId("create-pull-request-repository")).toHaveValue(
+    /:buzz$/,
+  );
+  await expect(page.getByTestId("create-pull-request-base-branch")).toHaveValue(
+    "main",
+  );
+  await expect(
+    page.getByTestId("create-pull-request-compare-branch"),
+  ).toHaveValue("feature/projects-workflow");
+  await page
+    .getByTestId("create-pull-request-title")
+    .fill("Complete the Projects git workflow");
+  await page
+    .getByTestId("create-pull-request-body")
+    .fill("Adds the missing desktop write path.");
+  await page.getByTestId("create-pull-request-submit").evaluate((button) => {
+    button.click();
+    button.click();
+  });
+  await expect(page.getByText("Pull request created.")).toBeVisible();
+
+  const createdEvents = await page.evaluate(
+    () =>
+      window.__BUZZ_E2E_SIGNED_EVENTS__?.filter(
+        (event) => event.kind === 1618,
+      ) ?? [],
+  );
+  expect(createdEvents).toHaveLength(1);
+  const [createdEvent] = createdEvents;
+  expect(createdEvent?.tags).toContainEqual([
+    "branch-name",
+    "feature/projects-workflow",
+  ]);
+  expect(createdEvent?.tags).toContainEqual(["target-branch", "main"]);
+  expect(createdEvent?.tags).toContainEqual([
+    "subject",
+    "Complete the Projects git workflow",
+  ]);
+
+  await page.getByRole("tab", { name: "Overview" }).click();
+  await page.evaluate(async () => {
+    const status = window.__BUZZ_E2E_PROJECT_REPO_SYNC_STATUS__;
+    if (!status) throw new Error("Missing mocked repository status.");
+    status.local_head = "abcdef0123456789abcdef0123456789abcdef01";
+    status.local_short_head = status.local_head.slice(0, 7);
+    status.ahead_count = 1;
+    status.can_push = true;
+    status.push_block_reason = null;
+    await window.__BUZZ_E2E_QUERY_CLIENT__?.invalidateQueries({
+      queryKey: ["project"],
+    });
+  });
+  await page.getByRole("button", { name: "Push", exact: true }).click();
+  await expect(page.getByText("mock project event rejection")).toBeVisible();
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () =>
+          window.__BUZZ_E2E_SIGNED_EVENTS__?.filter(
+            (event) => event.kind === 1619,
+          ).length ?? 0,
+      ),
+    )
+    .toBe(1);
+  await expect(
+    page.getByRole("button", { name: "Update PR", exact: true }),
+  ).toBeVisible();
+  await page.getByRole("button", { name: "Update PR", exact: true }).click();
+  await expect(page.getByText(/Pull request updated/)).toBeVisible();
+  await expect
+    .poll(() =>
+      page.evaluate(
+        () =>
+          window.__BUZZ_E2E_SIGNED_EVENTS__?.filter(
+            (event) => event.kind === 1619,
+          ).length ?? 0,
+      ),
+    )
+    .toBe(2);
+  await expect(
+    page.getByRole("button", { name: "Update PR", exact: true }),
+  ).toHaveCount(0);
+
+  const updateEvent = await page.evaluate(() =>
+    window.__BUZZ_E2E_SIGNED_EVENTS__
+      ?.filter((event) => event.kind === 1619)
+      .at(-1),
+  );
+  expect(updateEvent?.tags).toContainEqual([
+    "c",
+    "abcdef0123456789abcdef0123456789abcdef01",
+  ]);
+  expect(updateEvent?.tags.some((tag) => tag[0] === "E")).toBe(true);
+});
+
+test("project issue can be created from the issues header", async ({
+  page,
+}) => {
+  await enableProjectsFeature(page);
+  await installMockBridge(page);
+  await openBuzzProject(page);
+
+  await page.getByRole("tab", { name: "Issues", exact: true }).click();
+  await page.getByRole("button", { name: "Issues", exact: true }).click();
+  await page
+    .getByTestId("create-issue-title")
+    .fill("Document the broken workflow");
+  await page
+    .getByTestId("create-issue-body")
+    .fill("The project workflow needs a clear repair path.");
+  await page.getByTestId("create-issue-submit").click();
+  await expect(page.getByText("Issue created.")).toBeVisible();
+
+  const createdEvent = await page.evaluate(() =>
+    window.__BUZZ_E2E_SIGNED_EVENTS__?.find((event) => event.kind === 1621),
+  );
+  expect(createdEvent?.tags).toContainEqual([
+    "subject",
+    "Document the broken workflow",
+  ]);
 });