diff --git a/Cargo.toml b/Cargo.toml
index ff98a8e08..4c9029fe7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,6 @@ members = [
     "common",
     "mercury",
     "jupiter",
-    "venus",
     "ceres",
     "libra",
     "vault",
@@ -26,7 +25,6 @@ gateway = { path = "gateway" }
 common = { path = "common" }
 mercury = { path = "mercury" }
 jupiter = { path = "jupiter" }
-venus = { path = "venus" }
 ceres = { path = "ceres" }
 callisto = { path = "jupiter/callisto" }
 gemini = { path = "gemini" }
diff --git a/README.md b/README.md
index dfedf93d6..c298e5d0c 100644
--- a/README.md
+++ b/README.md
@@ -42,18 +42,23 @@ For now, we are developing on the macOS and Arch Linux. And quick start manuel i
 
 ![Mega Architect](docs/images/Mega_Bin_and_Modules.png)
 
-1. **mega** - The main entry of Mega.
-2. **gateway** - The Gateway module is responsible for handling `git`, `git-lfs` and web UI requests through the HTTP and SSH protocol. More information on the [Gateway](gateway/README.md).
-3. **libra** - The Libra is a `git` program that rewrite in Rust. More information on the [Libra](libra/README.md).
-4. **craft** - The Craft is `git` filters include `git-lfs` and `encrypt`/`decrypt` filer. More information on the [Craft](craft/README.md).
-5. **gemini** - The Gemini is a decentralized module of Mega. More information on the [Gemini](gemini/README.md).
-6. **scorpio** - The Scorpio is a FUSE filesystem that allow you to mount a Mega repository as a local filesystem. More information on the [Scorpio](scorpio/README.md).
-7. **mercury** - The Mercury module is the core module of Mega, which rewrites Git internal object like Blob, Tree, etc. More information on the [Mercury Module](mercury/README.md).
-8. **ceres** - The Ceres implement translate protocol for Mega. More information on the [Ceres](ceres/README.md).
-9. **jupiter** - The Jupiter is storage engine for Mega. More information on the [Jupiter](jupiter/README.md).
-10. **venus** - The Venus is a monorepo engine for Mega. More information on the [Venus](venus/README.md).
-11. **moon** - The Moon is a web UI for Mega. More information on the [Moon](moon/README.md).
-12. **mars** - The Mars is website for Mega. More information on the [Mars](mars/README.md).
+1. **mono** - Mega's api endpoint, responsible for handling `git`, `git-lfs` and web UI requests through the HTTP and SSH protocol.
+2. **mega** - The main entry of Mega, parse cli command with clap.
+3. **gateway** - The Gateway extend **mono** and contains ztm agent, which is responsible for ztm network capabilities. More information on the [Gateway](gateway/README.md).
+4. **libra** - The Libra is a `git` program that rewrite in Rust. More information on the [Libra](libra/README.md).
+5. **craft** - The Craft is `git` filters include `git-lfs` and `encrypt`/`decrypt` filer. More information on the [Craft](craft/README.md).
+6. **gemini** - The Gemini is a decentralized module of Mega. More information on the [Gemini](gemini/README.md).
+7. **scorpio** - The Scorpio is a FUSE filesystem that allow you to mount a Mega repository as a local filesystem. More information on the [Scorpio](scorpio/README.md).
+8. **mercury** - The Mercury module is the core module of Mega, which rewrites Git internal object like Blob, Tree, etc. More information on the [Mercury Module](mercury/README.md).
+9.  **ceres** - The Ceres is Mega's Monorepo Engine and implement the git transport protocol. More information on the [Ceres](ceres/README.md).
+10. **jupiter** - The Jupiter is storage engine for Mega. More information on the [Jupiter](jupiter/README.md).
+11. **saturn** - The Saturn module implement user permissions with Cedar policy [Saturn](saturn/README.md).
+12. **vault** -  The Vault module is used for key and certificate management, implemented with RustyVault
+13. **lunar** - The Lunar is a tauri app with Mega. More information on the [Lunar](lunar/README.md).
+14. **aries** - The Mega's ztm Relay Server. More information on the [Aries](aries/README.md).
+15. **altas** - AI API Module. More information on the [Altas](altas/README.md).
+16. **moon** - The Moon is a web UI for Mono Engine. More information on the [Moon](moon/README.md).
+17. **mars** - The Mars is website for Mega. More information on the [Mars](mars/README.md).
 
 
 
diff --git a/ceres/Cargo.toml b/ceres/Cargo.toml
index 7f79dc49b..fa0ee9682 100644
--- a/ceres/Cargo.toml
+++ b/ceres/Cargo.toml
@@ -15,7 +15,6 @@ common = { workspace = true }
 jupiter = { workspace = true }
 callisto = { workspace = true }
 mercury = { workspace = true }
-venus = { workspace = true }
 anyhow = { workspace = true }
 tokio = { workspace = true, features = ["net"] }
 tokio-stream = { workspace = true }
diff --git a/ceres/src/api_service/import_api_service.rs b/ceres/src/api_service/import_api_service.rs
index 87525b847..54d64948b 100644
--- a/ceres/src/api_service/import_api_service.rs
+++ b/ceres/src/api_service/import_api_service.rs
@@ -13,11 +13,11 @@ use mercury::errors::GitError;
 use mercury::internal::object::commit::Commit;
 use mercury::internal::object::tree::Tree;
 use mercury::internal::object::tree::TreeItem;
-use venus::import_repo::repo::Repo;
 
 use crate::api_service::ApiHandler;
 use crate::model::create_file::CreateFileInfo;
 use crate::model::publish_path::PublishPathInfo;
+use crate::protocol::repo::Repo;
 
 #[derive(Clone)]
 pub struct ImportApiService {
@@ -42,7 +42,7 @@ impl ApiHandler for ImportApiService {
     async fn get_raw_blob_by_hash(&self, hash: &str) -> Result<Option<raw_blob::Model>, MegaError> {
         self.context
             .services
-            .mega_storage
+            .mono_storage
             .get_raw_blob_by_hash(hash)
             .await
     }
@@ -58,9 +58,9 @@ impl ApiHandler for ImportApiService {
     }
     async fn get_root_commit(&self) -> Commit {
         let storage = self.context.services.git_db_storage.clone();
-        let refs = storage.get_default_ref(&self.repo).await.unwrap().unwrap();
+        let refs = storage.get_default_ref(self.repo.repo_id).await.unwrap().unwrap();
         storage
-            .get_commit_by_hash(&self.repo, &refs.ref_hash)
+            .get_commit_by_hash(self.repo.repo_id, &refs.ref_git_id)
             .await
             .unwrap()
             .unwrap()
@@ -69,15 +69,15 @@ impl ApiHandler for ImportApiService {
 
     async fn get_root_tree(&self) -> Tree {
         let storage = self.context.services.git_db_storage.clone();
-        let refs = storage.get_default_ref(&self.repo).await.unwrap().unwrap();
+        let refs = storage.get_default_ref(self.repo.repo_id).await.unwrap().unwrap();
 
         let root_commit = storage
-            .get_commit_by_hash(&self.repo, &refs.ref_hash)
+            .get_commit_by_hash(self.repo.repo_id, &refs.ref_git_id)
             .await
             .unwrap()
             .unwrap();
         storage
-            .get_tree_by_hash(&self.repo, &root_commit.tree)
+            .get_tree_by_hash(self.repo.repo_id, &root_commit.tree)
             .await
             .unwrap()
             .unwrap()
@@ -88,7 +88,7 @@ impl ApiHandler for ImportApiService {
         self.context
             .services
             .git_db_storage
-            .get_tree_by_hash(&self.repo, hash)
+            .get_tree_by_hash(self.repo.repo_id, hash)
             .await
             .unwrap()
             .unwrap()
@@ -98,12 +98,12 @@ impl ApiHandler for ImportApiService {
     async fn get_tree_relate_commit(&self, t_hash: &str) -> Commit {
         let storage = self.context.services.git_db_storage.clone();
         let tree_info = storage
-            .get_tree_by_hash(&self.repo, t_hash)
+            .get_tree_by_hash(self.repo.repo_id, t_hash)
             .await
             .unwrap()
             .unwrap();
         storage
-            .get_commit_by_hash(&self.repo, &tree_info.commit_id)
+            .get_commit_by_hash(self.repo.repo_id, &tree_info.commit_id)
             .await
             .unwrap()
             .unwrap()
@@ -117,7 +117,7 @@ impl ApiHandler for ImportApiService {
     ) {
         let storage = self.context.services.git_db_storage.clone();
         let trees = storage
-            .get_trees_by_hashes(&self.repo, hashes)
+            .get_trees_by_hashes(self.repo.repo_id, hashes)
             .await
             .unwrap();
         for tree in trees {
@@ -132,7 +132,7 @@ impl ApiHandler for ImportApiService {
     ) {
         let storage = self.context.services.git_db_storage.clone();
         let blobs = storage
-            .get_blobs_by_hashes(&self.repo, hashes)
+            .get_blobs_by_hashes(self.repo.repo_id, hashes)
             .await
             .unwrap();
         for blob in blobs {
@@ -143,7 +143,7 @@ impl ApiHandler for ImportApiService {
     async fn get_commits_by_hashes(&self, c_hashes: Vec<String>) -> Result<Vec<Commit>, GitError> {
         let storage = self.context.services.git_db_storage.clone();
         let commits = storage
-            .get_commits_by_hashes(&self.repo, &c_hashes)
+            .get_commits_by_hashes(self.repo.repo_id, &c_hashes)
             .await
             .unwrap();
         Ok(commits.into_iter().map(|x| x.into()).collect())
diff --git a/ceres/src/api_service/mod.rs b/ceres/src/api_service/mod.rs
index b326b8f61..abc0153eb 100644
--- a/ceres/src/api_service/mod.rs
+++ b/ceres/src/api_service/mod.rs
@@ -7,6 +7,7 @@ use axum::async_trait;
 
 use callisto::raw_blob;
 use common::errors::MegaError;
+use jupiter::utils::converter::generate_git_keep_with_timestamp;
 use mercury::{
     errors::GitError,
     internal::object::{
@@ -14,10 +15,11 @@ use mercury::{
         tree::{Tree, TreeItem, TreeItemMode},
     },
 };
-use venus::monorepo::converter;
 
 use crate::model::{
-    create_file::CreateFileInfo, publish_path::PublishPathInfo, tree::{LatestCommitInfo, TreeBriefItem, TreeCommitItem, UserInfo}
+    create_file::CreateFileInfo,
+    publish_path::PublishPathInfo,
+    tree::{LatestCommitInfo, TreeBriefItem, TreeCommitItem, UserInfo},
 };
 
 pub mod import_api_service;
@@ -314,7 +316,7 @@ pub trait ApiHandler: Send + Sync {
             }
         }
 
-        let blob = converter::generate_git_keep_with_timestamp();
+        let blob = generate_git_keep_with_timestamp();
         let mut last_tree = Tree::from_tree_items(vec![TreeItem {
             mode: TreeItemMode::Blob,
             id: blob.id,
diff --git a/ceres/src/api_service/mono_api_service.rs b/ceres/src/api_service/mono_api_service.rs
index 9c29d3b88..3ff2f988d 100644
--- a/ceres/src/api_service/mono_api_service.rs
+++ b/ceres/src/api_service/mono_api_service.rs
@@ -9,18 +9,19 @@ use callisto::{mega_blob, mega_tree, raw_blob};
 use common::errors::MegaError;
 use jupiter::context::Context;
 use jupiter::storage::batch_save_model;
+use jupiter::utils::converter::generate_git_keep_with_timestamp;
 use mercury::errors::GitError;
 use mercury::hash::SHA1;
 use mercury::internal::object::blob::Blob;
 use mercury::internal::object::commit::Commit;
 use mercury::internal::object::tree::{Tree, TreeItem, TreeItemMode};
-use venus::import_repo::repo::Repo;
-use venus::monorepo::converter;
 
 use crate::api_service::ApiHandler;
 use crate::model::create_file::CreateFileInfo;
 use crate::model::mr::{MRDetail, MrInfoItem};
 use crate::model::publish_path::PublishPathInfo;
+use crate::protocol::mr::MergeRequest;
+use crate::protocol::repo::Repo;
 
 #[derive(Clone)]
 pub struct MonoApiService {
@@ -39,7 +40,7 @@ impl ApiHandler for MonoApiService {
     ///
     /// Returns `Ok(())` on success, or a `GitError` on failure.
     async fn create_monorepo_file(&self, file_info: CreateFileInfo) -> Result<(), GitError> {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let path = PathBuf::from(file_info.path);
         let mut save_trees = vec![];
 
@@ -55,7 +56,7 @@ impl ApiHandler for MonoApiService {
             {
                 return Err(GitError::CustomError("Duplicate name".to_string()));
             }
-            let blob = converter::generate_git_keep_with_timestamp();
+            let blob = generate_git_keep_with_timestamp();
             let tree_item = TreeItem {
                 mode: TreeItemMode::Blob,
                 id: blob.id,
@@ -117,14 +118,14 @@ impl ApiHandler for MonoApiService {
     async fn publish_path(&self, publish_info: PublishPathInfo) -> Result<(), GitError> {
         let storage = self.context.services.git_db_storage.clone();
         let repo: Repo = publish_info.into();
-        storage.save_git_repo(repo.clone()).await.unwrap();
+        storage.save_git_repo(repo.clone().into()).await.unwrap();
         Ok(())
     }
 
     async fn get_raw_blob_by_hash(&self, hash: &str) -> Result<Option<raw_blob::Model>, MegaError> {
         self.context
             .services
-            .mega_storage
+            .mono_storage
             .get_raw_blob_by_hash(hash)
             .await
     }
@@ -138,7 +139,7 @@ impl ApiHandler for MonoApiService {
     }
 
     async fn get_root_tree(&self) -> Tree {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let refs = storage.get_ref("/").await.unwrap().unwrap();
 
         storage
@@ -152,7 +153,7 @@ impl ApiHandler for MonoApiService {
     async fn get_tree_by_hash(&self, hash: &str) -> Tree {
         self.context
             .services
-            .mega_storage
+            .mono_storage
             .get_tree_by_hash(hash)
             .await
             .unwrap()
@@ -161,7 +162,7 @@ impl ApiHandler for MonoApiService {
     }
 
     async fn get_tree_relate_commit(&self, t_hash: &str) -> Commit {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let tree_info = storage.get_tree_by_hash(t_hash).await.unwrap().unwrap();
         storage
             .get_commit_by_hash(&tree_info.commit_id)
@@ -176,7 +177,7 @@ impl ApiHandler for MonoApiService {
         item_to_commit: &mut HashMap<String, String>,
         hashes: Vec<String>,
     ) {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let trees = storage.get_trees_by_hashes(hashes).await.unwrap();
         for tree in trees {
             item_to_commit.insert(tree.tree_id, tree.commit_id);
@@ -188,7 +189,7 @@ impl ApiHandler for MonoApiService {
         item_to_commit: &mut HashMap<String, String>,
         hashes: Vec<String>,
     ) {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let blobs = storage.get_mega_blobs_by_hashes(hashes).await.unwrap();
         for blob in blobs {
             item_to_commit.insert(blob.blob_id, blob.commit_id);
@@ -196,7 +197,7 @@ impl ApiHandler for MonoApiService {
     }
 
     async fn get_commits_by_hashes(&self, c_hashes: Vec<String>) -> Result<Vec<Commit>, GitError> {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let commits = storage.get_commits_by_hashes(&c_hashes).await.unwrap();
         Ok(commits.into_iter().map(|x| x.into()).collect())
     }
@@ -208,7 +209,7 @@ impl ApiHandler for MonoApiService {
 
 impl MonoApiService {
     pub async fn init_monorepo(&self) {
-        self.context.services.mega_storage.init_monorepo().await
+        self.context.services.mono_storage.init_monorepo().await
     }
 
     pub async fn mr_list(&self, status: &str) -> Result<Vec<MrInfoItem>, MegaError> {
@@ -220,13 +221,13 @@ impl MonoApiService {
             vec![MergeStatus::Open, MergeStatus::Closed, MergeStatus::Merged]
             // return Err(MegaError::with_message("Invalid status name"));
         };
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let mr_list = storage.get_mr_by_status(status).await.unwrap();
         Ok(mr_list.into_iter().map(|m| m.into()).collect())
     }
 
     pub async fn mr_detail(&self, mr_id: i64) -> Result<Option<MRDetail>, MegaError> {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let model = storage.get_mr(mr_id).await.unwrap();
         if let Some(model) = model {
             let mut detail: MRDetail = model.into();
@@ -238,7 +239,7 @@ impl MonoApiService {
     }
 
     pub async fn mr_tree_files(&self, mr_id: i64) -> Result<Vec<PathBuf>, MegaError> {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let model = storage.get_mr(mr_id).await.unwrap();
         if let Some(model) = model {
             let to_tree_id = storage
@@ -293,14 +294,15 @@ impl MonoApiService {
     }
 
     pub async fn merge_mr(&self, mr_id: i64) -> Result<(), MegaError> {
-        let storage = self.context.services.mega_storage.clone();
-        if let Some(mut mr) = storage.get_open_mr_by_id(mr_id).await.unwrap() {
+        let storage = self.context.services.mono_storage.clone();
+        if let Some(model) = storage.get_open_mr_by_id(mr_id).await.unwrap() {
+            let mut mr: MergeRequest = model.into();
             let refs = storage.get_ref(&mr.path).await.unwrap().unwrap();
 
             if mr.from_hash == refs.ref_commit_hash {
                 // update mr
                 mr.merge();
-                storage.update_mr(mr.clone()).await.unwrap();
+                storage.update_mr(mr.clone().into()).await.unwrap();
 
                 let commit: Commit = storage
                     .get_commit_by_hash(&mr.to_hash)
@@ -343,7 +345,7 @@ impl MonoApiService {
         mut tree_vec: Vec<Tree>,
         commit: Commit,
     ) -> Result<String, GitError> {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let mut save_trees = Vec::new();
         let mut p_commit_id = String::new();
 
diff --git a/ceres/src/lfs/handler.rs b/ceres/src/lfs/handler.rs
index ac7ff226a..37fe7f04a 100644
--- a/ceres/src/lfs/handler.rs
+++ b/ceres/src/lfs/handler.rs
@@ -300,7 +300,7 @@ pub async fn lfs_upload_object(
             let sub_id = sha256::digest(chunk);
             let res = config
                 .lfs_storage
-                .put_object(&config.repo_name, &sub_id, chunk)
+                .put_object(0, &sub_id, chunk)
                 .await;
             if res.is_err() {
                 lfs_delete_meta(config.context.services.lfs_storage.clone(), request_vars)
@@ -327,7 +327,7 @@ pub async fn lfs_upload_object(
         // normal mode
         let res = config
             .lfs_storage
-            .put_object(&config.repo_name, &meta.oid, body_bytes)
+            .put_object(0, &meta.oid, body_bytes)
             .await;
         if res.is_err() {
             lfs_delete_meta(config.context.services.lfs_storage.clone(), request_vars)
@@ -359,7 +359,7 @@ pub async fn lfs_download_object(
                 for relation in relations {
                     let sub_bytes = config
                         .lfs_storage
-                        .get_object(&config.repo_name, &relation.sub_oid)
+                        .get_object(0, &relation.sub_oid)
                         .await
                         .unwrap();
                     let offset = relation.offset as usize;
@@ -382,7 +382,7 @@ pub async fn lfs_download_object(
 
                 let bytes = config
                     .lfs_storage
-                    .get_object(&config.repo_name, &sub_oid)
+                    .get_object(0, &sub_oid)
                     .await
                     .unwrap();
                 Ok(bytes)
@@ -394,7 +394,7 @@ pub async fn lfs_download_object(
             .unwrap();
         let bytes = config
             .lfs_storage
-            .get_object(&config.repo_name, &meta.oid)
+            .get_object(0, &meta.oid)
             .await
             .unwrap();
         Ok(bytes)
@@ -479,12 +479,12 @@ async fn lfs_file_exist(config: &LfsConfig, meta: &MetaObject) -> bool {
         relations.iter().all(|relation| {
             config
                 .lfs_storage
-                .exist_object(&config.repo_name, &relation.sub_oid)
+                .exist_object(0, &relation.sub_oid)
         })
     } else {
         config
             .lfs_storage
-            .exist_object(&config.repo_name, &meta.oid)
+            .exist_object(0, &meta.oid)
     }
 }
 
diff --git a/ceres/src/model/publish_path.rs b/ceres/src/model/publish_path.rs
index 6f1c516a5..65143f5e0 100644
--- a/ceres/src/model/publish_path.rs
+++ b/ceres/src/model/publish_path.rs
@@ -1,6 +1,7 @@
 use common::utils::generate_id;
 use serde::{Deserialize, Serialize};
-use venus::import_repo::repo::Repo;
+
+use crate::protocol::repo::Repo;
 
 #[derive(PartialEq, Eq, Debug, Clone, Default, Serialize, Deserialize)]
 pub struct PublishPathInfo {
diff --git a/ceres/src/pack/handler.rs b/ceres/src/pack/handler.rs
index dd57617f3..55b08a156 100644
--- a/ceres/src/pack/handler.rs
+++ b/ceres/src/pack/handler.rs
@@ -25,7 +25,7 @@ use mercury::{
         pack::entry::Entry,
     },
 };
-use venus::import_repo::import_refs::{RefCommand, Refs};
+use crate::protocol::import_refs::{RefCommand, Refs};
 
 #[async_trait]
 pub trait PackHandler: Send + Sync {
diff --git a/ceres/src/pack/import_repo.rs b/ceres/src/pack/import_repo.rs
index abf5782ad..656710da7 100644
--- a/ceres/src/pack/import_repo.rs
+++ b/ceres/src/pack/import_repo.rs
@@ -27,14 +27,10 @@ use mercury::{
     },
 };
 use mercury::{hash::SHA1, internal::pack::encode::PackEncoder};
-use venus::import_repo::{
-    import_refs::{CommandType, RefCommand, Refs},
-    repo::Repo,
-};
 
 use crate::{
     api_service::{mono_api_service::MonoApiService, ApiHandler},
-    pack::handler::PackHandler,
+    pack::handler::PackHandler, protocol::{import_refs::{CommandType, RefCommand, Refs}, repo::Repo},
 };
 
 pub struct ImportRepo {
@@ -45,13 +41,14 @@ pub struct ImportRepo {
 #[async_trait]
 impl PackHandler for ImportRepo {
     async fn head_hash(&self) -> (String, Vec<Refs>) {
-        let refs: Vec<Refs> = self
+        let result = self
             .context
             .services
             .git_db_storage
-            .get_ref(&self.repo)
+            .get_ref(self.repo.repo_id)
             .await
             .unwrap();
+        let refs: Vec<Refs> = result.into_iter().map(|x| x.into()).collect();
 
         self.find_head_hash(refs)
     }
@@ -67,14 +64,14 @@ impl PackHandler for ImportRepo {
                 let stg_clone = storage.clone();
                 let repo_clone = self.repo.clone();
                 let handle = tokio::spawn(async move {
-                    stg_clone.save_entry(&repo_clone, entry_list).await.unwrap();
+                    stg_clone.save_entry(repo_clone.repo_id, entry_list).await.unwrap();
                 });
                 join_tasks.push(handle);
                 entry_list = vec![];
             }
         }
         join_all(join_tasks).await;
-        storage.save_entry(&self.repo, entry_list).await.unwrap();
+        storage.save_entry(self.repo.repo_id, entry_list).await.unwrap();
         Ok(())
     }
 
@@ -84,13 +81,13 @@ impl PackHandler for ImportRepo {
         let (stream_tx, stream_rx) = mpsc::channel(pack_config.channel_message_size);
 
         let storage = self.context.services.git_db_storage.clone();
-        let total = storage.get_obj_count_by_repo_id(&self.repo).await;
+        let total = storage.get_obj_count_by_repo_id(self.repo.repo_id).await;
         let encoder = PackEncoder::new(total, 0, stream_tx);
         encoder.encode_async(entry_rx).await.unwrap();
 
-        let repo = self.repo.clone();
+        let repo_id = self.repo.repo_id;
         tokio::spawn(async move {
-            let mut commit_stream = storage.get_commits_by_repo_id(&repo).await.unwrap();
+            let mut commit_stream = storage.get_commits_by_repo_id(repo_id).await.unwrap();
 
             while let Some(model) = commit_stream.next().await {
                 match model {
@@ -104,7 +101,7 @@ impl PackHandler for ImportRepo {
             }
             tracing::info!("send commits end");
 
-            let mut tree_stream = storage.get_trees_by_repo_id(&repo).await.unwrap();
+            let mut tree_stream = storage.get_trees_by_repo_id(repo_id).await.unwrap();
             while let Some(model) = tree_stream.next().await {
                 match model {
                     Ok(m) => {
@@ -117,7 +114,7 @@ impl PackHandler for ImportRepo {
             }
             tracing::info!("send trees end");
 
-            let mut bid_stream = storage.get_blobs_by_repo_id(&repo).await.unwrap();
+            let mut bid_stream = storage.get_blobs_by_repo_id(repo_id).await.unwrap();
             let mut bids = vec![];
             while let Some(model) = bid_stream.next().await {
                 match model {
@@ -150,7 +147,7 @@ impl PackHandler for ImportRepo {
             join_all(blob_handler).await;
             tracing::info!("send blobs end");
 
-            let tags = storage.get_tags_by_repo_id(&repo).await.unwrap();
+            let tags = storage.get_tags_by_repo_id(repo_id).await.unwrap();
             for m in tags.into_iter() {
                 let c: Tag = m.into();
                 let entry: Entry = c.into();
@@ -176,7 +173,7 @@ impl PackHandler for ImportRepo {
         let mut exist_objs = HashSet::new();
 
         let mut want_commits: Vec<Commit> = storage
-            .get_commits_by_hashes(&self.repo, &want_clone)
+            .get_commits_by_hashes(self.repo.repo_id, &want_clone)
             .await
             .unwrap()
             .into_iter()
@@ -191,7 +188,7 @@ impl PackHandler for ImportRepo {
 
                 if !have.contains(&p_commit_id) && !want_clone.contains(&p_commit_id) {
                     let parent: Commit = storage
-                        .get_commit_by_hash(&self.repo, &p_commit_id)
+                        .get_commit_by_hash(self.repo.repo_id, &p_commit_id)
                         .await
                         .unwrap()
                         .unwrap()
@@ -208,7 +205,7 @@ impl PackHandler for ImportRepo {
             .map(|c| c.tree_id.to_plain_str())
             .collect();
         let want_trees: HashMap<SHA1, Tree> = storage
-            .get_trees_by_hashes(&self.repo, want_tree_ids)
+            .get_trees_by_hashes(self.repo.repo_id, want_tree_ids)
             .await
             .unwrap()
             .into_iter()
@@ -218,12 +215,12 @@ impl PackHandler for ImportRepo {
         obj_num.fetch_add(want_commits.len(), Ordering::SeqCst);
 
         let have_commits = storage
-            .get_commits_by_hashes(&self.repo, &have)
+            .get_commits_by_hashes(self.repo.repo_id, &have)
             .await
             .unwrap();
         let have_trees = storage
             .get_trees_by_hashes(
-                &self.repo,
+                self.repo.repo_id,
                 have_commits.iter().map(|x| x.tree.clone()).collect(),
             )
             .await
@@ -268,7 +265,7 @@ impl PackHandler for ImportRepo {
             .context
             .services
             .git_db_storage
-            .get_trees_by_hashes(&self.repo, hashes)
+            .get_trees_by_hashes(self.repo.repo_id, hashes)
             .await
             .unwrap()
             .into_iter()
@@ -282,7 +279,7 @@ impl PackHandler for ImportRepo {
     ) -> Result<Vec<raw_blob::Model>, MegaError> {
         self.context
             .services
-            .mega_storage
+            .mono_storage
             .get_raw_blobs_by_hashes(hashes)
             .await
     }
@@ -291,12 +288,12 @@ impl PackHandler for ImportRepo {
         let storage = self.context.services.git_db_storage.clone();
         match refs.command_type {
             CommandType::Create => {
-                storage.save_ref(&self.repo, refs).await.unwrap();
+                storage.save_ref(self.repo.repo_id, refs.clone().into()).await.unwrap();
             }
-            CommandType::Delete => storage.remove_ref(&self.repo, refs).await.unwrap(),
+            CommandType::Delete => storage.remove_ref(self.repo.repo_id, &refs.ref_name).await.unwrap(),
             CommandType::Update => {
                 storage
-                    .update_ref(&self.repo, &refs.ref_name, &refs.new_id)
+                    .update_ref(self.repo.repo_id, &refs.ref_name, &refs.new_id)
                     .await
                     .unwrap();
             }
@@ -308,7 +305,7 @@ impl PackHandler for ImportRepo {
         self.context
             .services
             .git_db_storage
-            .get_commit_by_hash(&self.repo, hash)
+            .get_commit_by_hash(self.repo.repo_id, hash)
             .await
             .unwrap()
             .is_some()
@@ -316,7 +313,7 @@ impl PackHandler for ImportRepo {
 
     async fn check_default_branch(&self) -> bool {
         let storage = self.context.services.git_db_storage.clone();
-        storage.default_branch_exist(&self.repo).await.unwrap()
+        storage.default_branch_exist(self.repo.repo_id).await.unwrap()
     }
 }
 
@@ -327,7 +324,7 @@ impl ImportRepo {
         let mono_api_service = MonoApiService {
             context: self.context.clone(),
         };
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let save_trees = mono_api_service.search_and_create_tree(&path).await?;
 
         let mut root_ref = storage.get_ref("/").await.unwrap().unwrap();
diff --git a/ceres/src/pack/monorepo.rs b/ceres/src/pack/monorepo.rs
index 0c43c61b7..3cd31e766 100644
--- a/ceres/src/pack/monorepo.rs
+++ b/ceres/src/pack/monorepo.rs
@@ -26,12 +26,15 @@ use mercury::{
         pack::entry::Entry,
     },
 };
-use venus::{
-    import_repo::import_refs::{RefCommand, Refs},
-    monorepo::mr::MergeRequest,
-};
 
-use crate::pack::handler::PackHandler;
+use crate::{
+    pack::handler::PackHandler,
+    protocol::{
+        import_refs::{RefCommand, Refs},
+        mega_refs::MegaRefs,
+        mr::MergeRequest,
+    },
+};
 
 pub struct MonoRepo {
     pub context: Context,
@@ -43,11 +46,12 @@ pub struct MonoRepo {
 #[async_trait]
 impl PackHandler for MonoRepo {
     async fn head_hash(&self) -> (String, Vec<Refs>) {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
 
         let result = storage.get_ref(self.path.to_str().unwrap()).await.unwrap();
         let refs = if result.is_some() {
-            vec![result.unwrap().into()]
+            let mega_refs: MegaRefs = result.unwrap().into();
+            vec![mega_refs.into()]
         } else {
             let target_path = self.path.clone();
             let refs = storage.get_ref("/").await.unwrap().unwrap();
@@ -116,7 +120,7 @@ impl PackHandler for MonoRepo {
     }
 
     async fn handle_receiver(&self, receiver: Receiver<Entry>) -> Result<(), GitError> {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
 
         let (mut mr, mr_exist) = self.get_mr().await;
 
@@ -153,11 +157,11 @@ impl PackHandler for MonoRepo {
                     .await
                     .unwrap();
             }
-            storage.update_mr(mr.clone()).await.unwrap();
+            storage.update_mr(mr.clone().into()).await.unwrap();
         } else {
             unpack_res = self.save_entry(receiver).await;
             if unpack_res.is_ok() {
-                storage.save_mr(mr.clone()).await.unwrap();
+                storage.save_mr(mr.clone().into()).await.unwrap();
             }
         };
         unpack_res
@@ -166,7 +170,7 @@ impl PackHandler for MonoRepo {
     // monorepo full pack should follow the shallow clone command 'git clone --depth=1'
     async fn full_pack(&self) -> Result<ReceiverStream<Vec<u8>>, GitError> {
         let pack_config = &self.context.config.pack;
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let obj_num = AtomicUsize::new(0);
 
         let refs = storage
@@ -210,7 +214,7 @@ impl PackHandler for MonoRepo {
     ) -> Result<ReceiverStream<Vec<u8>>, GitError> {
         let mut want_clone = want.clone();
         let pack_config = &self.context.config.pack;
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let obj_num = AtomicUsize::new(0);
 
         let mut exist_objs = HashSet::new();
@@ -300,7 +304,7 @@ impl PackHandler for MonoRepo {
         Ok(self
             .context
             .services
-            .mega_storage
+            .mono_storage
             .get_trees_by_hashes(hashes)
             .await
             .unwrap()
@@ -315,7 +319,7 @@ impl PackHandler for MonoRepo {
     ) -> Result<Vec<raw_blob::Model>, MegaError> {
         self.context
             .services
-            .mega_storage
+            .mono_storage
             .get_raw_blobs_by_hashes(hashes)
             .await
     }
@@ -328,7 +332,7 @@ impl PackHandler for MonoRepo {
     async fn check_commit_exist(&self, hash: &str) -> bool {
         self.context
             .services
-            .mega_storage
+            .mono_storage
             .get_commit_by_hash(hash)
             .await
             .unwrap()
@@ -342,14 +346,14 @@ impl PackHandler for MonoRepo {
 
 impl MonoRepo {
     async fn get_mr(&self) -> (MergeRequest, bool) {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
 
         let mr = storage
             .get_open_mr(self.path.to_str().unwrap())
             .await
             .unwrap();
         if let Some(mr) = mr {
-            (mr, true)
+            (mr.into(), true)
         } else {
             let mr = MergeRequest {
                 path: self.path.to_str().unwrap().to_owned(),
@@ -370,7 +374,7 @@ impl MonoRepo {
     }
 
     async fn save_entry(&self, receiver: Receiver<Entry>) -> Result<(), GitError> {
-        let storage = self.context.services.mega_storage.clone();
+        let storage = self.context.services.mono_storage.clone();
         let mut entry_list = Vec::new();
         let mut join_tasks = vec![];
         let mut current_commit_id = String::new();
@@ -398,7 +402,10 @@ impl MonoRepo {
             entry_list.push(entry);
         }
         join_all(join_tasks).await;
-        storage.save_entry(&current_commit_id, entry_list).await.unwrap();
+        storage
+            .save_entry(&current_commit_id, entry_list)
+            .await
+            .unwrap();
         Ok(())
     }
 }
diff --git a/venus/src/import_repo/import_refs.rs b/ceres/src/protocol/import_refs.rs
similarity index 100%
rename from venus/src/import_repo/import_refs.rs
rename to ceres/src/protocol/import_refs.rs
diff --git a/venus/src/monorepo/mega_refs.rs b/ceres/src/protocol/mega_refs.rs
similarity index 96%
rename from venus/src/monorepo/mega_refs.rs
rename to ceres/src/protocol/mega_refs.rs
index d41281a83..cf8324fe5 100644
--- a/venus/src/monorepo/mega_refs.rs
+++ b/ceres/src/protocol/mega_refs.rs
@@ -4,7 +4,7 @@ use callisto::mega_refs;
 
 use common::utils::MEGA_BRANCH_NAME;
 
-use crate::import_repo::import_refs::Refs;
+use crate::protocol::import_refs::Refs;
 
 #[derive(Clone, Serialize, Deserialize, Default)]
 pub struct MegaRefs {
diff --git a/ceres/src/protocol/mod.rs b/ceres/src/protocol/mod.rs
index ddc3a36ad..9441cfc59 100644
--- a/ceres/src/protocol/mod.rs
+++ b/ceres/src/protocol/mod.rs
@@ -6,12 +6,17 @@ use common::{
     errors::{MegaError, ProtocolError},
     utils::ZERO_ID,
 };
+use import_refs::RefCommand;
 use jupiter::context::Context;
-use venus::{import_repo::import_refs::RefCommand, import_repo::repo::Repo};
+use repo::Repo;
 
 use crate::pack::{handler::PackHandler, import_repo::ImportRepo, monorepo::MonoRepo};
 
 pub mod smart;
+pub mod repo;
+pub mod import_refs;
+pub mod mr;
+pub mod mega_refs;
 
 #[derive(Clone)]
 pub struct SmartProtocol {
@@ -159,7 +164,7 @@ impl SmartProtocol {
                     }
                     ServiceType::ReceivePack => {
                         let repo = Repo::new(self.path.clone(), false);
-                        storage.save_git_repo(repo.clone()).await.unwrap();
+                        storage.save_git_repo(repo.clone().into()).await.unwrap();
                         repo
                     }
                 }
diff --git a/venus/src/monorepo/mr.rs b/ceres/src/protocol/mr.rs
similarity index 100%
rename from venus/src/monorepo/mr.rs
rename to ceres/src/protocol/mr.rs
diff --git a/venus/src/import_repo/repo.rs b/ceres/src/protocol/repo.rs
similarity index 100%
rename from venus/src/import_repo/repo.rs
rename to ceres/src/protocol/repo.rs
diff --git a/ceres/src/protocol/smart.rs b/ceres/src/protocol/smart.rs
index d9e55fc55..06e7a06cb 100644
--- a/ceres/src/protocol/smart.rs
+++ b/ceres/src/protocol/smart.rs
@@ -10,8 +10,9 @@ use common::errors::ProtocolError;
 
 use crate::protocol::ZERO_ID;
 use crate::protocol::{
-    Capability, RefCommand, ServiceType, SideBind, SmartProtocol, TransportProtocol,
+    Capability, ServiceType, SideBind, SmartProtocol, TransportProtocol,
 };
+use crate::protocol::import_refs::RefCommand;
 
 const LF: char = '\n';
 
@@ -400,7 +401,7 @@ pub fn read_pkt_line(bytes: &mut Bytes) -> (usize, Bytes) {
 pub mod test {
     use bytes::{Bytes, BytesMut};
     use callisto::db_enums::RefType;
-    use venus::import_repo::import_refs::{CommandType, RefCommand};
+    use crate::protocol::import_refs::{CommandType, RefCommand};
 
     use crate::protocol::smart::{add_pkt_line_string, read_pkt_line, read_until_white_space};
     use crate::protocol::{Capability, SmartProtocol};
diff --git a/gateway/src/https_server.rs b/gateway/src/https_server.rs
index 1a9c36844..2d510c1f5 100644
--- a/gateway/src/https_server.rs
+++ b/gateway/src/https_server.rs
@@ -120,7 +120,7 @@ pub async fn app(
     ztm: ZtmOptions,
 ) -> Router {
     let context = Context::new(config.clone()).await;
-    context.services.mega_storage.init_monorepo().await;
+    context.services.mono_storage.init_monorepo().await;
     let state = AppState {
         host,
         port,
diff --git a/gemini/Cargo.toml b/gemini/Cargo.toml
index cf1784771..460d0a573 100644
--- a/gemini/Cargo.toml
+++ b/gemini/Cargo.toml
@@ -22,5 +22,5 @@ chrono = { workspace = true }
 jupiter = { workspace = true }
 vault = { workspace = true }
 callisto = { workspace = true }
-venus = { workspace = true }
+ceres = { workspace = true }
 neptune = { workspace = true }
\ No newline at end of file
diff --git a/gemini/src/http/handler.rs b/gemini/src/http/handler.rs
index 9e14b4336..cd60bceb7 100644
--- a/gemini/src/http/handler.rs
+++ b/gemini/src/http/handler.rs
@@ -1,5 +1,5 @@
 use jupiter::context::Context;
-use venus::import_repo::repo::Repo;
+use ceres::protocol::repo::Repo;
 
 use crate::{
     ztm::agent::{share_repo, LocalZTMAgent, ZTMAgent},
@@ -33,7 +33,7 @@ pub async fn repo_provide(
     let git_ref = context
         .services
         .git_db_storage
-        .get_default_ref(&repo)
+        .get_default_ref(repo.repo_id)
         .await
         .unwrap()
         .unwrap();
@@ -48,7 +48,7 @@ pub async fn repo_provide(
         identifier,
         origin: peer_id.clone(),
         update_time,
-        commit: git_ref.ref_hash,
+        commit: git_ref.ref_git_id,
         peer_online: true,
     };
     share_repo(url.clone(), repo_info).await;
diff --git a/jupiter/Cargo.toml b/jupiter/Cargo.toml
index 03e137cbe..2eafd277b 100644
--- a/jupiter/Cargo.toml
+++ b/jupiter/Cargo.toml
@@ -13,7 +13,6 @@ path = "src/lib.rs"
 [dependencies]
 callisto = { workspace = true }
 common = { workspace = true }
-venus = { workspace = true }
 mercury = { workspace = true }
 sea-orm = { workspace = true, features = [
     "sqlx-postgres",
@@ -29,6 +28,7 @@ async-trait = { workspace = true }
 futures = { workspace = true }
 serde_json = { workspace = true }
 idgenerator = { workspace = true }
+serde = { workspace = true }
 handlebars = "6.0.0"
 
 [dev-dependencies]
diff --git a/jupiter/callisto/Cargo.toml b/jupiter/callisto/Cargo.toml
index d1c75148e..ee7fb1e92 100644
--- a/jupiter/callisto/Cargo.toml
+++ b/jupiter/callisto/Cargo.toml
@@ -9,7 +9,7 @@ name = "callisto"
 path = "src/lib.rs"
 
 [dependencies]
-common = { path = "../../common" }
+common = { workspace = true }
 
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true }
diff --git a/jupiter/src/context.rs b/jupiter/src/context.rs
index 27e2eff41..1b836ddb2 100644
--- a/jupiter/src/context.rs
+++ b/jupiter/src/context.rs
@@ -3,7 +3,8 @@ use std::sync::Arc;
 use common::config::Config;
 
 use crate::storage::{
-    git_db_storage::GitDbStorage, init::database_connection, lfs_storage::LfsStorage, mega_storage::MegaStorage, mq_storage::MQStorage, ztm_storage::ZTMStorage
+    git_db_storage::GitDbStorage, init::database_connection, lfs_storage::LfsStorage,
+    mono_storage::MonoStorage, mq_storage::MQStorage, ztm_storage::ZTMStorage,
 };
 
 #[derive(Clone)]
@@ -29,7 +30,7 @@ impl Context {
 
 #[derive(Clone)]
 pub struct Service {
-    pub mega_storage: Arc<MegaStorage>,
+    pub mono_storage: Arc<MonoStorage>,
     pub git_db_storage: Arc<GitDbStorage>,
     pub lfs_storage: Arc<LfsStorage>,
     pub ztm_storage: Arc<ZTMStorage>,
@@ -40,8 +41,8 @@ impl Service {
     async fn new(config: &Config) -> Service {
         let connection = Arc::new(database_connection(&config.database).await);
         Service {
-            mega_storage: Arc::new(
-                MegaStorage::new(connection.clone(), config.storage.clone()).await,
+            mono_storage: Arc::new(
+                MonoStorage::new(connection.clone(), config.storage.clone()).await,
             ),
             git_db_storage: Arc::new(
                 GitDbStorage::new(connection.clone(), config.storage.clone()).await,
@@ -58,7 +59,7 @@ impl Service {
 
     fn mock() -> Arc<Self> {
         Arc::new(Self {
-            mega_storage: Arc::new(MegaStorage::mock()),
+            mono_storage: Arc::new(MonoStorage::mock()),
             git_db_storage: Arc::new(GitDbStorage::mock()),
             lfs_storage: Arc::new(LfsStorage::mock()),
             ztm_storage: Arc::new(ZTMStorage::mock()),
diff --git a/jupiter/src/raw_storage/local_storage.rs b/jupiter/src/raw_storage/local_storage.rs
index 15fbca4dc..fd278c74a 100644
--- a/jupiter/src/raw_storage/local_storage.rs
+++ b/jupiter/src/raw_storage/local_storage.rs
@@ -28,8 +28,8 @@ impl RawStorage for LocalStorage {
         StorageType::LocalFs
     }
 
-    async fn get_ref(&self, repo_name: &str, ref_name: &str) -> Result<String, MegaError> {
-        let path = Path::new(&self.base_path).join(repo_name).join(ref_name);
+    async fn get_ref(&self, repo_id: i64, ref_name: &str) -> Result<String, MegaError> {
+        let path = Path::new(&self.base_path).join(repo_id.to_string()).join(ref_name);
         let mut file = fs::File::open(path)?;
         let mut buf = String::new();
         file.read_to_string(&mut buf)?;
@@ -38,11 +38,11 @@ impl RawStorage for LocalStorage {
 
     async fn put_ref(
         &self,
-        repo_name: &str,
+        repo_id: i64,
         ref_name: &str,
         ref_hash: &str,
     ) -> Result<(), MegaError> {
-        let path = Path::new(&self.base_path).join(repo_name).join(ref_name);
+        let path = Path::new(&self.base_path).join(repo_id.to_string()).join(ref_name);
         let parent = path.parent().unwrap();
         fs::create_dir_all(parent)?;
         let mut file = fs::File::create(path)?;
@@ -50,26 +50,26 @@ impl RawStorage for LocalStorage {
         Ok(())
     }
 
-    async fn delete_ref(&self, repo_name: &str, ref_name: &str) -> Result<(), MegaError> {
-        let path = Path::new(&self.base_path).join(repo_name).join(ref_name);
+    async fn delete_ref(&self, repo_id: i64, ref_name: &str) -> Result<(), MegaError> {
+        let path = Path::new(&self.base_path).join(repo_id.to_string()).join(ref_name);
         Ok(fs::remove_file(path)?)
     }
 
     async fn update_ref(
         &self,
-        repo_name: &str,
+        repo_id: i64,
         ref_name: &str,
         ref_hash: &str,
     ) -> Result<(), MegaError> {
-        let path = Path::new(&self.base_path).join(repo_name).join(ref_name);
+        let path = Path::new(&self.base_path).join(repo_id.to_string()).join(ref_name);
         let mut file = OpenOptions::new().write(true).open(path).unwrap();
         file.write_all(ref_hash.as_bytes()).unwrap();
         Ok(())
     }
 
-    async fn get_object(&self, repo_name: &str, object_id: &str) -> Result<Bytes, MegaError> {
+    async fn get_object(&self, repo_id: i64, object_id: &str) -> Result<Bytes, MegaError> {
         let path = Path::new(&self.base_path)
-            .join(repo_name)
+            .join(repo_id.to_string())
             .join("objects")
             .join(self.transform_path(object_id));
         let mut file =
@@ -81,12 +81,12 @@ impl RawStorage for LocalStorage {
 
     async fn put_object(
         &self,
-        repo_name: &str,
+        repo_id: i64,
         object_id: &str,
         body_content: &[u8],
     ) -> Result<String, MegaError> {
         let path = Path::new(&self.base_path)
-            .join(repo_name)
+            .join(repo_id.to_string())
             .join("objects")
             .join(self.transform_path(object_id));
         let dir = path.parent().unwrap();
@@ -97,9 +97,9 @@ impl RawStorage for LocalStorage {
         Ok(path.to_str().unwrap().to_string())
     }
 
-    fn exist_object(&self, repo_name: &str, object_id: &str) -> bool {
+    fn exist_object(&self, repo_id: i64, object_id: &str) -> bool {
         let path = Path::new(&self.base_path)
-            .join(repo_name)
+            .join(repo_id.to_string())
             .join("objects")
             .join(self.transform_path(object_id));
         Path::exists(&path)
@@ -124,9 +124,9 @@ mod tests {
         source.push("tests/objects");
 
         let local_storage = LocalStorage::init(source.clone());
-        assert!(local_storage.put_object("", &oid, &content).await.is_ok());
+        assert!(local_storage.put_object(0, &oid, &content).await.is_ok());
 
-        assert!(local_storage.exist_object("", &oid));
+        assert!(local_storage.exist_object(0, &oid));
     }
 
     #[tokio::test]
@@ -137,7 +137,7 @@ mod tests {
 
         storage
             .put_ref(
-                "",
+                0,
                 "refs/tags/1.0",
                 "5bb8ee25bac1014c15abc49c56d1ee0aab1050cb",
             )
@@ -160,7 +160,7 @@ mod tests {
 
         // run test code
         storage
-            .update_ref("", ref_name, "04ea005354bbbf8bf676fd97d8993a66ffeaa472")
+            .update_ref(0, ref_name, "04ea005354bbbf8bf676fd97d8993a66ffeaa472")
             .await
             .unwrap();
         let buf = fs::read_to_string(&ref_path).unwrap();
@@ -178,7 +178,7 @@ mod tests {
         fs::write(&ref_path, "5bb8ee25bac1014c15abc49c56d1ee0aab1050cb").unwrap();
 
         let storage = LocalStorage::init(test_path.clone());
-        storage.delete_ref("", ref_name).await.unwrap();
+        storage.delete_ref(0, ref_name).await.unwrap();
         let ref_path = test_path.join(ref_name);
         assert!(!Path::exists(&ref_path));
     }
@@ -188,7 +188,7 @@ mod tests {
         let mut test_path = PathBuf::from(env::current_dir().unwrap().parent().unwrap());
         test_path.push("tests");
         let storage = LocalStorage::init(test_path.clone());
-        let ref_hash = storage.get_ref("", "refs/heads/master").await.unwrap();
+        let ref_hash = storage.get_ref(0, "refs/heads/master").await.unwrap();
         assert_eq!(ref_hash, "5bb8ee25bac1014c15abc49c56d1ee0aab1050cb")
     }
 }
diff --git a/jupiter/src/raw_storage/mod.rs b/jupiter/src/raw_storage/mod.rs
index 140e1743c..b3f473af0 100644
--- a/jupiter/src/raw_storage/mod.rs
+++ b/jupiter/src/raw_storage/mod.rs
@@ -30,29 +30,29 @@ pub struct BlobLink {
 pub trait RawStorage: Sync + Send {
     fn get_storage_type(&self) -> StorageType;
 
-    async fn get_ref(&self, repo_name: &str, ref_name: &str) -> Result<String, MegaError>;
+    async fn get_ref(&self, repo_id: i64, ref_name: &str) -> Result<String, MegaError>;
 
     async fn put_ref(
         &self,
-        repo_name: &str,
+        repo_id: i64,
         ref_name: &str,
         ref_hash: &str,
     ) -> Result<(), MegaError>;
 
-    async fn delete_ref(&self, repo_name: &str, ref_name: &str) -> Result<(), MegaError>;
+    async fn delete_ref(&self, repo_id: i64, ref_name: &str) -> Result<(), MegaError>;
 
     async fn update_ref(
         &self,
-        repo_name: &str,
+        repo_id: i64,
         ref_name: &str,
         ref_hash: &str,
     ) -> Result<(), MegaError>;
 
-    async fn get_object(&self, repo_name: &str, object_id: &str) -> Result<Bytes, MegaError>;
+    async fn get_object(&self, repo_id: i64, object_id: &str) -> Result<Bytes, MegaError>;
 
     async fn put_object(
         &self,
-        repo_name: &str,
+        repo_id: i64,
         object_id: &str,
         body_content: &[u8],
     ) -> Result<String, MegaError>;
@@ -71,9 +71,9 @@ pub trait RawStorage: Sync + Send {
     // }
 
     // save a entry and return the b_link file
-    async fn convert_blink(&self, repo_name: &str, entry: &Entry) -> Result<Vec<u8>, MegaError> {
+    async fn convert_blink(&self, repo_id: i64, entry: &Entry) -> Result<Vec<u8>, MegaError> {
         let location = self
-            .put_object(repo_name, &entry.hash.to_plain_str(), &entry.data)
+            .put_object(repo_id, &entry.hash.to_plain_str(), &entry.data)
             .await
             .unwrap();
         let handlebars = Handlebars::new();
@@ -103,7 +103,7 @@ pub trait RawStorage: Sync + Send {
         Ok(rendered.into_bytes())
     }
 
-    fn exist_object(&self, repo_name: &str, object_id: &str) -> bool;
+    fn exist_object(&self, repo_id: i64, object_id: &str) -> bool;
 
     fn transform_path(&self, sha1: &str) -> String {
         if sha1.len() < 5 {
diff --git a/jupiter/src/storage/git_db_storage.rs b/jupiter/src/storage/git_db_storage.rs
index 3805789bb..2a81c6cac 100644
--- a/jupiter/src/storage/git_db_storage.rs
+++ b/jupiter/src/storage/git_db_storage.rs
@@ -14,9 +14,6 @@ use common::config::StorageConfig;
 use common::errors::MegaError;
 use mercury::internal::object::GitObjectModel;
 use mercury::internal::pack::entry::Entry;
-use venus::import_repo::import_refs::RefCommand;
-use venus::import_repo::import_refs::Refs;
-use venus::import_repo::repo::Repo;
 
 use crate::{
     raw_storage::{self, RawStorage},
@@ -43,10 +40,10 @@ struct GitObjects {
 
 #[async_trait]
 impl GitStorageProvider for GitDbStorage {
-    async fn save_ref(&self, repo: &Repo, refs: &RefCommand) -> Result<(), MegaError> {
-        let mut model: import_refs::Model = refs.clone().into();
-        model.repo_id = repo.repo_id;
-        let a_model = model.into_active_model();
+    async fn save_ref(&self, repo_id: i64, mut refs: import_refs::Model) -> Result<(), MegaError> {
+        // let mut model: import_refs::Model = refs.clone().into();
+        refs.repo_id = repo_id;
+        let a_model = refs.into_active_model();
         import_refs::Entity::insert(a_model)
             .exec(self.get_connection())
             .await
@@ -54,28 +51,32 @@ impl GitStorageProvider for GitDbStorage {
         Ok(())
     }
 
-    async fn remove_ref(&self, repo: &Repo, refs: &RefCommand) -> Result<(), MegaError> {
+    async fn remove_ref(&self, repo_id: i64, ref_name: &str) -> Result<(), MegaError> {
         import_refs::Entity::delete_many()
-            .filter(import_refs::Column::RepoId.eq(repo.repo_id))
-            .filter(import_refs::Column::RefName.eq(refs.ref_name.clone()))
+            .filter(import_refs::Column::RepoId.eq(repo_id))
+            .filter(import_refs::Column::RefName.eq(ref_name))
             .exec(self.get_connection())
             .await?;
         Ok(())
     }
 
-    async fn get_ref(&self, repo: &Repo) -> Result<Vec<Refs>, MegaError> {
+    async fn get_ref(&self, repo_id: i64) -> Result<Vec<import_refs::Model>, MegaError> {
         let result = import_refs::Entity::find()
-            .filter(import_refs::Column::RepoId.eq(repo.repo_id))
+            .filter(import_refs::Column::RepoId.eq(repo_id))
             .order_by_asc(import_refs::Column::RefName)
             .all(self.get_connection())
             .await?;
-        let res: Vec<Refs> = result.into_iter().map(|x| x.into()).collect();
-        Ok(res)
+        Ok(result)
     }
 
-    async fn update_ref(&self, repo: &Repo, ref_name: &str, new_id: &str) -> Result<(), MegaError> {
+    async fn update_ref(
+        &self,
+        repo_id: i64,
+        ref_name: &str,
+        new_id: &str,
+    ) -> Result<(), MegaError> {
         let ref_data: import_refs::Model = import_refs::Entity::find()
-            .filter(import_refs::Column::RepoId.eq(repo.repo_id))
+            .filter(import_refs::Column::RepoId.eq(repo_id))
             .filter(import_refs::Column::RefName.eq(ref_name))
             .one(self.get_connection())
             .await
@@ -111,30 +112,34 @@ impl GitDbStorage {
         }
     }
 
-    pub async fn get_default_ref(&self, repo: &Repo) -> Result<Option<Refs>, MegaError> {
+    pub async fn get_default_ref(
+        &self,
+        repo_id: i64,
+    ) -> Result<Option<import_refs::Model>, MegaError> {
         let result = import_refs::Entity::find()
-            .filter(import_refs::Column::RepoId.eq(repo.repo_id))
+            .filter(import_refs::Column::RepoId.eq(repo_id))
             .filter(import_refs::Column::DefaultBranch.eq(true))
             .one(self.get_connection())
             .await?;
-        if let Some(model) = result {
-            let refs: Refs = model.into();
-            Ok(Some(refs))
-        } else {
-            Ok(None)
-        }
+        Ok(result)
+        // if let Some(model) = result {
+        //     let refs: Refs = model.into();
+        //     Ok(Some(refs))
+        // } else {
+        //     Ok(None)
+        // }
     }
 
-    pub async fn default_branch_exist(&self, repo: &Repo) -> Result<bool, MegaError> {
+    pub async fn default_branch_exist(&self, repo_id: i64) -> Result<bool, MegaError> {
         let result = import_refs::Entity::find()
-            .filter(import_refs::Column::RepoId.eq(repo.repo_id))
+            .filter(import_refs::Column::RepoId.eq(repo_id))
             .filter(import_refs::Column::DefaultBranch.eq(true))
             .count(self.get_connection())
             .await?;
         Ok(result > 0)
     }
 
-    pub async fn save_entry(&self, repo: &Repo, entry_list: Vec<Entry>) -> Result<(), MegaError> {
+    pub async fn save_entry(&self, repo_id: i64, entry_list: Vec<Entry>) -> Result<(), MegaError> {
         let git_objects = Arc::new(Mutex::new(GitObjects {
             commits: Vec::new(),
             trees: Vec::new(),
@@ -154,20 +159,20 @@ impl GitDbStorage {
 
                     match model {
                         GitObjectModel::Commit(mut commit) => {
-                            commit.repo_id = repo.repo_id;
+                            commit.repo_id = repo_id;
                             git_objects.commits.push(commit.into_active_model())
                         }
                         GitObjectModel::Tree(mut tree) => {
-                            tree.repo_id = repo.repo_id;
+                            tree.repo_id = repo_id;
                             git_objects.trees.push(tree.clone().into_active_model());
                         }
                         GitObjectModel::Blob(mut blob, raw) => {
-                            blob.repo_id = repo.repo_id;
+                            blob.repo_id = repo_id;
                             git_objects.blobs.push(blob.clone().into_active_model());
                             git_objects.raw_blobs.push(raw.into_active_model());
                         }
                         GitObjectModel::Tag(mut tag) => {
-                            tag.repo_id = repo.repo_id;
+                            tag.repo_id = repo_id;
                             git_objects.tags.push(tag.into_active_model())
                         }
                     }
@@ -240,9 +245,9 @@ impl GitDbStorage {
         Ok(result)
     }
 
-    pub async fn save_git_repo(&self, repo: Repo) -> Result<(), MegaError> {
-        let model: git_repo::Model = repo.into();
-        let a_model = model.into_active_model();
+    pub async fn save_git_repo(&self, repo: git_repo::Model) -> Result<(), MegaError> {
+        // let model: git_repo::Model = repo.into();
+        let a_model = repo.into_active_model();
         git_repo::Entity::insert(a_model)
             .exec(self.get_connection())
             .await
@@ -252,11 +257,11 @@ impl GitDbStorage {
 
     pub async fn get_commit_by_hash(
         &self,
-        repo: &Repo,
+        repo_id: i64,
         hash: &str,
     ) -> Result<Option<git_commit::Model>, MegaError> {
         Ok(git_commit::Entity::find()
-            .filter(git_commit::Column::RepoId.eq(repo.repo_id))
+            .filter(git_commit::Column::RepoId.eq(repo_id))
             .filter(git_commit::Column::CommitId.eq(hash))
             .one(self.get_connection())
             .await
@@ -265,35 +270,35 @@ impl GitDbStorage {
 
     pub async fn get_commits_by_hashes(
         &self,
-        repo: &Repo,
+        repo_id: i64,
         hashes: &Vec<String>,
     ) -> Result<Vec<git_commit::Model>, MegaError> {
         Ok(git_commit::Entity::find()
-            .filter(git_commit::Column::RepoId.eq(repo.repo_id))
+            .filter(git_commit::Column::RepoId.eq(repo_id))
             .filter(git_commit::Column::CommitId.is_in(hashes))
             .all(self.get_connection())
             .await
             .unwrap())
     }
 
-    pub async fn get_commits_by_repo_id<'a>(
-        &'a self,
-        repo: &'a Repo,
-    ) -> Result<impl Stream<Item = Result<git_commit::Model, DbErr>> + 'a + Send, MegaError> {
+    pub async fn get_commits_by_repo_id(
+        &self,
+        repo_id: i64,
+    ) -> Result<impl Stream<Item = Result<git_commit::Model, DbErr>> + Send + '_, MegaError> {
         let stream = git_commit::Entity::find()
-            .filter(git_commit::Column::RepoId.eq(repo.repo_id))
+            .filter(git_commit::Column::RepoId.eq(repo_id))
             .stream(self.get_connection())
             .await
             .unwrap();
         Ok(stream)
     }
 
-    pub async fn get_trees_by_repo_id<'a>(
-        &'a self,
-        repo: &'a Repo,
-    ) -> Result<impl Stream<Item = Result<git_tree::Model, DbErr>> + 'a + Send, MegaError> {
+    pub async fn get_trees_by_repo_id(
+        &self,
+        repo_id: i64,
+    ) -> Result<impl Stream<Item = Result<git_tree::Model, DbErr>> + '_ + Send, MegaError> {
         Ok(git_tree::Entity::find()
-            .filter(git_tree::Column::RepoId.eq(repo.repo_id))
+            .filter(git_tree::Column::RepoId.eq(repo_id))
             .stream(self.get_connection())
             .await
             .unwrap())
@@ -301,11 +306,11 @@ impl GitDbStorage {
 
     pub async fn get_trees_by_hashes(
         &self,
-        repo: &Repo,
+        repo_id: i64,
         hashes: Vec<String>,
     ) -> Result<Vec<git_tree::Model>, MegaError> {
         Ok(git_tree::Entity::find()
-            .filter(git_tree::Column::RepoId.eq(repo.repo_id))
+            .filter(git_tree::Column::RepoId.eq(repo_id))
             .filter(git_tree::Column::TreeId.is_in(hashes))
             .all(self.get_connection())
             .await
@@ -314,23 +319,23 @@ impl GitDbStorage {
 
     pub async fn get_tree_by_hash(
         &self,
-        repo: &Repo,
+        repo_id: i64,
         hash: &str,
     ) -> Result<Option<git_tree::Model>, MegaError> {
         Ok(git_tree::Entity::find()
-            .filter(git_tree::Column::RepoId.eq(repo.repo_id))
+            .filter(git_tree::Column::RepoId.eq(repo_id))
             .filter(git_tree::Column::TreeId.eq(hash))
             .one(self.get_connection())
             .await
             .unwrap())
     }
 
-    pub async fn get_blobs_by_repo_id<'a>(
-        &'a self,
-        repo: &'a Repo,
-    ) -> Result<impl Stream<Item = Result<git_blob::Model, DbErr>> + 'a + Send, MegaError> {
+    pub async fn get_blobs_by_repo_id(
+        & self,
+        repo_id: i64,
+    ) -> Result<impl Stream<Item = Result<git_blob::Model, DbErr>> + '_ + Send, MegaError> {
         Ok(git_blob::Entity::find()
-            .filter(git_blob::Column::RepoId.eq(repo.repo_id))
+            .filter(git_blob::Column::RepoId.eq(repo_id))
             .stream(self.get_connection())
             .await
             .unwrap())
@@ -338,11 +343,11 @@ impl GitDbStorage {
 
     pub async fn get_blobs_by_hashes(
         &self,
-        repo: &Repo,
+        repo_id: i64,
         hashes: Vec<String>,
     ) -> Result<Vec<git_blob::Model>, MegaError> {
         Ok(git_blob::Entity::find()
-            .filter(git_blob::Column::RepoId.eq(repo.repo_id))
+            .filter(git_blob::Column::RepoId.eq(repo_id))
             .filter(git_blob::Column::BlobId.is_in(hashes))
             .all(self.get_connection())
             .await
@@ -360,35 +365,38 @@ impl GitDbStorage {
             .unwrap())
     }
 
-    pub async fn get_tags_by_repo_id(&self, repo: &Repo) -> Result<Vec<git_tag::Model>, MegaError> {
+    pub async fn get_tags_by_repo_id(
+        &self,
+        repo_id: i64,
+    ) -> Result<Vec<git_tag::Model>, MegaError> {
         Ok(git_tag::Entity::find()
-            .filter(git_tag::Column::RepoId.eq(repo.repo_id))
+            .filter(git_tag::Column::RepoId.eq(repo_id))
             .all(self.get_connection())
             .await
             .unwrap())
     }
 
-    pub async fn get_obj_count_by_repo_id(&self, repo: &Repo) -> usize {
+    pub async fn get_obj_count_by_repo_id(&self, repo_id: i64) -> usize {
         let c_count = git_commit::Entity::find()
-            .filter(git_commit::Column::RepoId.eq(repo.repo_id))
+            .filter(git_commit::Column::RepoId.eq(repo_id))
             .count(self.get_connection())
             .await
             .unwrap();
 
         let t_count = git_tree::Entity::find()
-            .filter(git_tree::Column::RepoId.eq(repo.repo_id))
+            .filter(git_tree::Column::RepoId.eq(repo_id))
             .count(self.get_connection())
             .await
             .unwrap();
 
         let b_count = git_blob::Entity::find()
-            .filter(git_blob::Column::RepoId.eq(repo.repo_id))
+            .filter(git_blob::Column::RepoId.eq(repo_id))
             .count(self.get_connection())
             .await
             .unwrap();
 
         let tag_count = git_tag::Entity::find()
-            .filter(git_tag::Column::RepoId.eq(repo.repo_id))
+            .filter(git_tag::Column::RepoId.eq(repo_id))
             .count(self.get_connection())
             .await
             .unwrap();
diff --git a/jupiter/src/storage/git_fs_storage.rs b/jupiter/src/storage/git_fs_storage.rs
index 0354a535c..e8fd95a74 100644
--- a/jupiter/src/storage/git_fs_storage.rs
+++ b/jupiter/src/storage/git_fs_storage.rs
@@ -2,6 +2,7 @@ use std::{io::Cursor, sync::Arc};
 
 use async_trait::async_trait;
 
+use callisto::import_refs;
 use common::{config::StorageConfig, errors::MegaError};
 use mercury::{
     hash::SHA1,
@@ -10,10 +11,6 @@ use mercury::{
         pack::entry::Entry,
     },
 };
-use venus::{
-    import_repo::import_refs::{RefCommand, Refs},
-    import_repo::repo::Repo,
-};
 
 use crate::{
     raw_storage::{self, RawStorage},
@@ -26,28 +23,29 @@ pub struct GitFsStorage {
 
 #[async_trait]
 impl GitStorageProvider for GitFsStorage {
-    async fn save_ref(&self, repo: &Repo, refs: &RefCommand) -> Result<(), MegaError> {
+    async fn save_ref(&self, repo_id: i64, refs: import_refs::Model) -> Result<(), MegaError> {
         self.raw_storage
-            .put_ref(&repo.repo_name, &refs.ref_name, &refs.new_id)
+            .put_ref(repo_id, &refs.ref_name, &refs.ref_git_id)
             .await
     }
 
-    async fn remove_ref(&self, repo: &Repo, refs: &RefCommand) -> Result<(), MegaError> {
-        self.raw_storage
-            .delete_ref(&repo.repo_name, &refs.ref_name)
-            .await
+    async fn remove_ref(&self, repo_id: i64, ref_name: &str) -> Result<(), MegaError> {
+        self.raw_storage.delete_ref(repo_id, ref_name).await
     }
 
-    async fn get_ref(&self, _repo: &Repo) -> Result<Vec<Refs>, MegaError> {
+    async fn get_ref(&self, _repo_id: i64) -> Result<Vec<import_refs::Model>, MegaError> {
         // let ref_hash = self.raw_storage.get_ref(&repo.repo_name, ref_name).await;
         // if let Some()
         todo!()
     }
 
-    async fn update_ref(&self, repo: &Repo, ref_name: &str, new_id: &str) -> Result<(), MegaError> {
-        self.raw_storage
-            .update_ref(&repo.repo_name, ref_name, new_id)
-            .await
+    async fn update_ref(
+        &self,
+        repo_id: i64,
+        ref_name: &str,
+        new_id: &str,
+    ) -> Result<(), MegaError> {
+        self.raw_storage.update_ref(repo_id, ref_name, new_id).await
     }
 }
 
@@ -65,10 +63,10 @@ impl GitFsStorage {
         }
     }
 
-    pub async fn save_entry(&self, repo: &Repo, entry_list: Vec<Entry>) -> Result<(), MegaError> {
+    pub async fn save_entry(&self, repo_id: i64, entry_list: Vec<Entry>) -> Result<(), MegaError> {
         for entry in entry_list {
             self.raw_storage
-                .put_object(&repo.repo_name, &entry.hash.to_plain_str(), &entry.data)
+                .put_object(repo_id, &entry.hash.to_plain_str(), &entry.data)
                 .await
                 .unwrap();
         }
@@ -77,14 +75,14 @@ impl GitFsStorage {
 
     pub async fn get_entry_by_sha1(
         &self,
-        repo: Repo,
+        repo_id: i64,
         sha1_vec: Vec<&str>,
     ) -> Result<Vec<Entry>, MegaError> {
         let mut res: Vec<Entry> = Vec::new();
         for sha1 in sha1_vec {
             let data = self
                 .raw_storage
-                .get_object(&repo.repo_name, sha1)
+                .get_object(repo_id, sha1)
                 .await
                 .unwrap();
             let (type_num, _) = utils::read_type_and_size(&mut Cursor::new(&data)).unwrap();
diff --git a/jupiter/src/storage/mod.rs b/jupiter/src/storage/mod.rs
index 59ac5d8f7..63b6b3a50 100644
--- a/jupiter/src/storage/mod.rs
+++ b/jupiter/src/storage/mod.rs
@@ -2,32 +2,28 @@ pub mod git_db_storage;
 pub mod git_fs_storage;
 pub mod init;
 pub mod lfs_storage;
-pub mod mega_storage;
+pub mod mono_storage;
 pub mod mq_storage;
 pub mod ztm_storage;
 
 use async_trait::async_trait;
 
+use callisto::import_refs;
 use common::errors::MegaError;
 use sea_orm::{sea_query::OnConflict, ActiveModelTrait, ConnectionTrait, EntityTrait};
-use venus::{
-    import_repo::import_refs::{RefCommand, Refs},
-    import_repo::repo::Repo,
-};
-
 ///
 /// This interface is designed to handle the commonalities between the database storage and
 /// file system storage.
 ///
 #[async_trait]
 pub trait GitStorageProvider: Send + Sync {
-    async fn save_ref(&self, repo: &Repo, refs: &RefCommand) -> Result<(), MegaError>;
+    async fn save_ref(&self, repo_id: i64, refs: import_refs::Model) -> Result<(), MegaError>;
 
-    async fn remove_ref(&self, repo: &Repo, refs: &RefCommand) -> Result<(), MegaError>;
+    async fn remove_ref(&self, repo_id: i64, ref_name: &str) -> Result<(), MegaError>;
 
-    async fn get_ref(&self, repo: &Repo) -> Result<Vec<Refs>, MegaError>;
+    async fn get_ref(&self, repo_id: i64) -> Result<Vec<import_refs::Model>, MegaError>;
 
-    async fn update_ref(&self, repo: &Repo, ref_name: &str, new_id: &str) -> Result<(), MegaError>;
+    async fn update_ref(&self, repo_id: i64, ref_name: &str, new_id: &str) -> Result<(), MegaError>;
 
     // async fn save_entry(&self, repo: &Repo, entry_list: Vec<Entry>) -> Result<(), MegaError>;
 
diff --git a/jupiter/src/storage/mega_storage.rs b/jupiter/src/storage/mono_storage.rs
similarity index 90%
rename from jupiter/src/storage/mega_storage.rs
rename to jupiter/src/storage/mono_storage.rs
index ca0f86abe..b513eb552 100644
--- a/jupiter/src/storage/mega_storage.rs
+++ b/jupiter/src/storage/mono_storage.rs
@@ -17,15 +17,13 @@ use common::errors::MegaError;
 use common::utils::generate_id;
 use mercury::internal::object::MegaObjectModel;
 use mercury::internal::{object::commit::Commit, pack::entry::Entry};
-use venus::monorepo::converter::MegaModelConverter;
-use venus::monorepo::mega_refs::MegaRefs;
-use venus::monorepo::mr::MergeRequest;
 
 use crate::raw_storage::{self, RawStorage};
 use crate::storage::batch_save_model;
+use crate::utils::converter::MegaModelConverter;
 
 #[derive(Clone)]
-pub struct MegaStorage {
+pub struct MonoStorage {
     pub raw_storage: Arc<dyn RawStorage>,
     pub connection: Arc<DatabaseConnection>,
     pub raw_obj_threshold: usize,
@@ -40,13 +38,13 @@ struct GitObjects {
     tags: Vec<mega_tag::ActiveModel>,
 }
 
-impl MegaStorage {
+impl MonoStorage {
     pub fn get_connection(&self) -> &DatabaseConnection {
         &self.connection
     }
 
     pub async fn new(connection: Arc<DatabaseConnection>, config: StorageConfig) -> Self {
-        MegaStorage {
+        MonoStorage {
             connection,
             raw_storage: raw_storage::init(config.raw_obj_storage_type, config.raw_obj_local_path)
                 .await,
@@ -55,7 +53,7 @@ impl MegaStorage {
     }
 
     pub fn mock() -> Self {
-        MegaStorage {
+        MonoStorage {
             connection: Arc::new(DatabaseConnection::default()),
             raw_storage: raw_storage::mock(),
             raw_obj_threshold: 1024,
@@ -92,24 +90,23 @@ impl MegaStorage {
         Ok(())
     }
 
-    pub async fn remove_ref(&self, refs: MegaRefs) -> Result<(), MegaError> {
+    pub async fn remove_ref(&self, refs: mega_refs::Model) -> Result<(), MegaError> {
         mega_refs::Entity::delete_by_id(refs.id)
             .exec(self.get_connection())
             .await?;
         Ok(())
     }
 
-    pub async fn get_ref(&self, path: &str) -> Result<Option<MegaRefs>, MegaError> {
+    pub async fn get_ref(&self, path: &str) -> Result<Option<mega_refs::Model>, MegaError> {
         let result = mega_refs::Entity::find()
             .filter(mega_refs::Column::Path.eq(path))
             .one(self.get_connection())
             .await?;
-        Ok(result.map(|model| model.into()))
+        Ok(result)
     }
 
-    pub async fn update_ref(&self, refs: MegaRefs) -> Result<(), MegaError> {
-        let ref_data: mega_refs::Model = refs.into();
-        let mut ref_data: mega_refs::ActiveModel = ref_data.into();
+    pub async fn update_ref(&self, refs: mega_refs::Model) -> Result<(), MegaError> {
+        let mut ref_data: mega_refs::ActiveModel = refs.into();
         ref_data.reset(mega_refs::Column::RefCommitHash);
         ref_data.reset(mega_refs::Column::RefTreeHash);
         ref_data.reset(mega_refs::Column::UpdatedAt);
@@ -117,18 +114,14 @@ impl MegaStorage {
         Ok(())
     }
 
-    pub async fn get_open_mr(&self, path: &str) -> Result<Option<MergeRequest>, MegaError> {
+    pub async fn get_open_mr(&self, path: &str) -> Result<Option<mega_mr::Model>, MegaError> {
         let model = mega_mr::Entity::find()
             .filter(mega_mr::Column::Path.eq(path))
             .filter(mega_mr::Column::Status.eq(MergeStatus::Open))
             .one(self.get_connection())
             .await
             .unwrap();
-        if let Some(model) = model {
-            let mr: MergeRequest = model.into();
-            return Ok(Some(mr));
-        }
-        Ok(None)
+        Ok(model)
     }
 
     pub async fn get_mr_by_status(
@@ -152,29 +145,30 @@ impl MegaStorage {
         Ok(model)
     }
 
-    pub async fn get_open_mr_by_id(&self, mr_id: i64) -> Result<Option<MergeRequest>, MegaError> {
+    pub async fn get_open_mr_by_id(&self, mr_id: i64) -> Result<Option<mega_mr::Model>, MegaError> {
         let model = mega_mr::Entity::find_by_id(mr_id)
             .filter(mega_mr::Column::Status.eq(MergeStatus::Open))
             .one(self.get_connection())
             .await
             .unwrap();
-        if let Some(model) = model {
-            let mr: MergeRequest = model.into();
-            return Ok(Some(mr));
-        }
-        Ok(None)
+        // if let Some(model) = model {
+        //     let mr: MergeRequest = model.into();
+        //     return Ok(Some(mr));
+        // }
+        // Ok(None)
+        Ok(model)
     }
 
-    pub async fn save_mr(&self, mr: MergeRequest) -> Result<(), MegaError> {
-        let model: mega_mr::Model = mr.into();
-        let a_model = model.into_active_model();
+    pub async fn save_mr(&self, mr: mega_mr::Model) -> Result<(), MegaError> {
+        // let model: mega_mr::Model = mr.into();
+        let a_model = mr.into_active_model();
         a_model.insert(self.get_connection()).await.unwrap();
         Ok(())
     }
 
-    pub async fn update_mr(&self, mr: MergeRequest) -> Result<(), MegaError> {
-        let model: mega_mr::Model = mr.into();
-        let mut a_model = model.into_active_model();
+    pub async fn update_mr(&self, mr: mega_mr::Model) -> Result<(), MegaError> {
+        // let model: mega_mr::Model = mr.into();
+        let mut a_model = mr.into_active_model();
         a_model = a_model.reset_all();
         a_model.created_at = NotSet;
         a_model.update(self.get_connection()).await.unwrap();
diff --git a/venus/src/monorepo/converter.rs b/jupiter/src/utils/converter.rs
similarity index 98%
rename from venus/src/monorepo/converter.rs
rename to jupiter/src/utils/converter.rs
index d669044e6..9385c51ed 100644
--- a/venus/src/monorepo/converter.rs
+++ b/jupiter/src/utils/converter.rs
@@ -140,7 +140,7 @@ mod test {
 
     use mercury::{hash::SHA1, internal::object::commit::Commit};
 
-    use crate::monorepo::converter::MegaModelConverter;
+    use crate::utils::converter::MegaModelConverter;
 
     #[test]
     pub fn test_init_mega_dir() {
diff --git a/jupiter/src/utils/mod.rs b/jupiter/src/utils/mod.rs
index e6e877b9c..bcf83163d 100644
--- a/jupiter/src/utils/mod.rs
+++ b/jupiter/src/utils/mod.rs
@@ -1 +1,2 @@
+pub mod converter;
 pub mod id_generator;
diff --git a/mega/src/commands/init.rs b/mega/src/commands/init.rs
index e1c217c9c..e3ba5d8d6 100644
--- a/mega/src/commands/init.rs
+++ b/mega/src/commands/init.rs
@@ -18,7 +18,7 @@ pub fn cli() -> Command {
 #[tokio::main]
 pub(crate) async fn exec(config: Config, _: &ArgMatches) -> MegaResult {
     let context = Context::new(config).await;
-    context.services.mega_storage.init_monorepo().await;
+    context.services.mono_storage.init_monorepo().await;
     Ok(())
 }
 
diff --git a/mercury/src/internal/pack/cache_object.rs b/mercury/src/internal/pack/cache_object.rs
index 7ecc7badc..2e7766665 100644
--- a/mercury/src/internal/pack/cache_object.rs
+++ b/mercury/src/internal/pack/cache_object.rs
@@ -157,7 +157,7 @@ impl CacheObject {
         }
     }
 
-    /// transform the CacheObject to venus::internal::pack::entry::Entry
+    /// transform the CacheObject to Entry
     pub fn to_entry(&self) -> Entry {
         match self.obj_type {
             ObjectType::Blob | ObjectType::Tree | ObjectType::Commit | ObjectType::Tag => {
diff --git a/mono/Cargo.toml b/mono/Cargo.toml
index a13bd6920..9c1211548 100644
--- a/mono/Cargo.toml
+++ b/mono/Cargo.toml
@@ -18,7 +18,6 @@ jupiter = { workspace = true }
 callisto = { workspace = true }
 ceres = { workspace = true }
 vault = { workspace = true }
-venus = { workspace = true }
 mercury = { workspace = true }
 taurus = { workspace = true }
 
diff --git a/mono/src/api/mod.rs b/mono/src/api/mod.rs
index 5a59e3bd8..9b11f644b 100644
--- a/mono/src/api/mod.rs
+++ b/mono/src/api/mod.rs
@@ -1,11 +1,13 @@
 use std::path::PathBuf;
 
-use ceres::api_service::{
-    import_api_service::ImportApiService, mono_api_service::MonoApiService, ApiHandler,
+use ceres::{
+    api_service::{
+        import_api_service::ImportApiService, mono_api_service::MonoApiService, ApiHandler,
+    },
+    protocol::repo::Repo,
 };
 use common::model::CommonOptions;
 use jupiter::context::Context;
-use venus::import_repo::repo::Repo;
 
 pub mod api_router;
 pub mod mr_router;
diff --git a/mono/src/commands/init.rs b/mono/src/commands/init.rs
index fd7474572..7d51ab5ca 100644
--- a/mono/src/commands/init.rs
+++ b/mono/src/commands/init.rs
@@ -19,7 +19,7 @@ pub fn cli() -> Command {
 pub(crate) async fn exec(config: Config, _: &ArgMatches) -> MegaResult {
 
     let context = Context::new(config).await;
-    context.services.mega_storage.init_monorepo().await;
+    context.services.mono_storage.init_monorepo().await;
     Ok(())
 }
 
diff --git a/mono/src/server/https_server.rs b/mono/src/server/https_server.rs
index c9522f7c1..6465a0300 100644
--- a/mono/src/server/https_server.rs
+++ b/mono/src/server/https_server.rs
@@ -126,7 +126,7 @@ pub async fn start_http(config: Config, options: HttpOptions) {
 
 pub async fn app(config: Config, host: String, port: u16, common: CommonOptions) -> Router {
     let context = Context::new(config.clone()).await;
-    context.services.mega_storage.init_monorepo().await;
+    context.services.mono_storage.init_monorepo().await;
     let state = AppState {
         host,
         port,
diff --git a/venus/Cargo.toml b/venus/Cargo.toml
deleted file mode 100644
index 5b0ad5843..000000000
--- a/venus/Cargo.toml
+++ /dev/null
@@ -1,20 +0,0 @@
-[package]
-name = "venus"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-common = { workspace = true }
-callisto = { workspace = true }
-mercury = { workspace = true }
-serde = { workspace = true, features = ["derive"] }
-bstr = { workspace = true }
-hex = { workspace = true }
-thiserror = { workspace = true }
-flate2 = { workspace = true }
-tracing = { workspace = true }
-sha1 = { workspace = true }
-colored = { workspace = true }
-chrono = { workspace = true }
\ No newline at end of file
diff --git a/venus/README.md b/venus/README.md
deleted file mode 100644
index b3970763e..000000000
--- a/venus/README.md
+++ /dev/null
@@ -1 +0,0 @@
-## Venus Module
\ No newline at end of file
diff --git a/venus/src/import_repo/mod.rs b/venus/src/import_repo/mod.rs
deleted file mode 100644
index 1a3d394fa..000000000
--- a/venus/src/import_repo/mod.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub mod repo;
-pub mod import_refs;
\ No newline at end of file
diff --git a/venus/src/lib.rs b/venus/src/lib.rs
deleted file mode 100644
index 24db42f76..000000000
--- a/venus/src/lib.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-pub mod monorepo;
-pub mod import_repo;
diff --git a/venus/src/monorepo/mod.rs b/venus/src/monorepo/mod.rs
deleted file mode 100644
index 9b0cc77df..000000000
--- a/venus/src/monorepo/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod converter;
-pub mod mega_refs;
-pub mod mr;