diff --git a/libra/src/command/clone.rs b/libra/src/command/clone.rs
index bb3b17138..823f86b8f 100644
--- a/libra/src/command/clone.rs
+++ b/libra/src/command/clone.rs
@@ -15,8 +15,6 @@ use std::cell::Cell;
 use std::path::PathBuf;
 use std::{env, fs};
 
-const ORIGIN: &str = "origin"; // default remote name, prevent spelling mistakes
-
 #[derive(Parser, Debug)]
 pub struct CloneArgs {
     /// The remote repository location to clone from, usually a URL with HTTPS or SSH
@@ -98,10 +96,10 @@ pub async fn execute(args: CloneArgs) {
         name: "origin".to_string(),
         url: remote_repo.clone(),
     };
-    fetch::fetch_repository(remote_config, args.branch.clone()).await;
+    fetch::fetch_repository(remote_config.clone(), args.branch.clone()).await;
 
     /* setup */
-    if let Err(e) = setup_repository(remote_repo.clone(), args.branch.clone()).await {
+    if let Err(e) = setup_repository(remote_config, args.branch.clone()).await {
         eprintln!("fatal: {}", e);
         return;
     }
@@ -112,11 +110,11 @@ pub async fn execute(args: CloneArgs) {
 /// Sets up the local repository after a clone by configuring the remote,
 /// setting up the initial branch and HEAD, and creating the first reflog entry.
 async fn setup_repository(
-    remote_repo: String,
+    remote_config: RemoteConfig,
     specified_branch: Option<String>,
 ) -> Result<(), String> {
     let db = crate::internal::db::get_db_conn_instance().await;
-    let remote_head = Head::remote_current_with_conn(db, ORIGIN).await;
+    let remote_head = Head::remote_current_with_conn(db, &remote_config.name).await;
 
     // Determine which branch to check out.
     let branch_to_checkout = match specified_branch {
@@ -131,13 +129,14 @@ async fn setup_repository(
     };
 
     if let Some(branch_name) = branch_to_checkout {
-        let origin_branch = Branch::find_branch_with_conn(db, &branch_name, Some(ORIGIN))
-            .await
-            .ok_or_else(|| format!("fatal: remote branch '{}' not found.", branch_name))?;
+        let origin_branch =
+            Branch::find_branch_with_conn(db, &branch_name, Some(&remote_config.name))
+                .await
+                .ok_or_else(|| format!("fatal: remote branch '{}' not found.", branch_name))?;
 
         // Prepare the reflog context *before* the transaction
         let action = ReflogAction::Clone {
-            from: remote_repo.clone(),
+            from: remote_config.url.clone(),
         };
 
         let context = ReflogContext {
@@ -174,12 +173,24 @@ async fn setup_repository(
                         &merge_ref,
                     )
                     .await;
-                    Config::insert_with_conn(txn, "branch", Some(&branch_name), "remote", ORIGIN)
-                        .await;
+                    Config::insert_with_conn(
+                        txn,
+                        "branch",
+                        Some(&branch_name),
+                        "remote",
+                        &remote_config.name,
+                    )
+                    .await;
 
                     // 4. Configure the remote URL
-                    Config::insert_with_conn(txn, "remote", Some(ORIGIN), "url", &remote_repo)
-                        .await;
+                    Config::insert_with_conn(
+                        txn,
+                        "remote",
+                        Some(&remote_config.name),
+                        "url",
+                        &remote_config.url,
+                    )
+                    .await;
                     Ok(())
                 })
             },
@@ -200,13 +211,25 @@ async fn setup_repository(
         println!("warning: You appear to have cloned an empty repository.");
 
         // We only need to set the remote URL. No reflog is created as there are no commits.
-        Config::insert("remote", Some(ORIGIN), "url", &remote_repo).await;
+        Config::insert(
+            "remote",
+            Some(&remote_config.name),
+            "url",
+            &remote_config.url,
+        )
+        .await;
 
         // Optionally set up a default branch config for a future 'master' or 'main'
         let default_branch = "master";
         let merge_ref = format!("refs/heads/{}", default_branch);
         Config::insert("branch", Some(default_branch), "merge", &merge_ref).await;
-        Config::insert("branch", Some(default_branch), "remote", ORIGIN).await;
+        Config::insert(
+            "branch",
+            Some(default_branch),
+            "remote",
+            &remote_config.name,
+        )
+        .await;
     }
 
     Ok(())
diff --git a/libra/src/command/fetch.rs b/libra/src/command/fetch.rs
index b193c5bf4..5a8762710 100644
--- a/libra/src/command/fetch.rs
+++ b/libra/src/command/fetch.rs
@@ -12,7 +12,7 @@ use tokio::io::{AsyncRead, AsyncReadExt};
 use tokio_util::io::StreamReader;
 use url::Url;
 
-use crate::command::load_object;
+use crate::command::{load_object, HEAD};
 use crate::internal::db::get_db_conn_instance;
 use crate::internal::reflog;
 use crate::internal::reflog::{zero_sha1, ReflogAction, ReflogContext, ReflogError};
@@ -235,24 +235,34 @@ pub async fn fetch_repository(remote_config: RemoteConfig, branch: Option<String
 
                     // Determine the full ref name (e.g., "refs/remotes/origin/main")
                     if let Some(branch_name) = r._ref.strip_prefix("refs/heads/") {
-                        full_ref_name =
-                            format!("refs/remotes/{}/{}", remote_config.name, branch_name);
+                        full_ref_name = branch_name.to_owned();
                     } else if let Some(mr_name) = r._ref.strip_prefix("refs/mr/") {
                         // Handle merge requests if your system supports them
-                        full_ref_name =
-                            format!("refs/remotes/{}/mr/{}", remote_config.name, mr_name);
+                        full_ref_name = format!("mr/{}", mr_name);
+                    } else if r._ref == HEAD {
+                        continue;
                     } else {
                         tracing::warn!("Unsupported ref type during fetch: {}", r._ref);
                         continue; // Skip unsupported ref types
                     }
 
                     // Get the old OID *before* updating the branch
-                    let old_oid = Branch::find_branch_with_conn(txn, &full_ref_name, None)
-                        .await
-                        .map_or(zero_sha1().to_string(), |b| b.commit.to_string());
+                    let old_oid = Branch::find_branch_with_conn(
+                        txn,
+                        &full_ref_name,
+                        Some(&remote_config.name),
+                    )
+                    .await
+                    .map_or(zero_sha1().to_string(), |b| b.commit.to_string());
 
                     // Update the branch pointer
-                    Branch::update_branch_with_conn(txn, &full_ref_name, &r._hash, None).await;
+                    Branch::update_branch_with_conn(
+                        txn,
+                        &full_ref_name,
+                        &r._hash,
+                        Some(&remote_config.name),
+                    )
+                    .await;
 
                     // Prepare and insert the reflog entry for this specific remote-tracking branch
                     let context = ReflogContext {
diff --git a/libra/src/internal/config.rs b/libra/src/internal/config.rs
index 08682ad88..faa4f77aa 100644
--- a/libra/src/internal/config.rs
+++ b/libra/src/internal/config.rs
@@ -11,6 +11,7 @@ use crate::internal::model::config::{self, ActiveModel, Model};
 
 pub struct Config;
 
+#[derive(Clone)]
 pub struct RemoteConfig {
     pub name: String,
     pub url: String,