refactor: share Pool via Rc<RefCell>

Convert Pool to Rc<RefCell<Pool>> so Solver, Decisions, and
RuleSetGenerator share it, resolving the todo!() placeholders that
blocked the dependency resolver (Phase C shared ownership).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

38 files changed, 213 insertions, 220 deletions

diff --git a/crates/shirabe/src/command/archive_command.rs b/crates/shirabe/src/command/archive_command.rs
index 01da89d..c88b47b 100644
--- a/crates/shirabe/src/command/archive_command.rs
+++ b/crates/shirabe/src/command/archive_command.rs
@@ -184,7 +184,7 @@ impl ArchiveCommand {
             let download_manager =
                 factory.create_download_manager(io, config, &http_downloader, &process, None)?;
             let loop_ = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(
-                std::rc::Rc::clone(&http_downloader),
+                http_downloader.clone(),
                 Some(process),
             )));
             owned_archive_manager =
diff --git a/crates/shirabe/src/command/base_config_command.rs b/crates/shirabe/src/command/base_config_command.rs
index 2da93dc..85e68b3 100644
--- a/crates/shirabe/src/command/base_config_command.rs
+++ b/crates/shirabe/src/command/base_config_command.rs
@@ -41,7 +41,7 @@ pub trait BaseConfigCommand: BaseCommand {
         *self.config_mut() = Some(std::rc::Rc::new(std::cell::RefCell::new(
             Factory::create_config(Some(io.as_ref()), None)?,
         )));
-        let config_rc = std::rc::Rc::clone(self.config().unwrap());
+        let config_rc = self.config().unwrap().clone();
 
         // When using --global flag, set baseDir to home directory for correct absolute path resolution
         if input.get_option("global").as_bool().unwrap_or(false) {
diff --git a/crates/shirabe/src/command/create_project_command.rs b/crates/shirabe/src/command/create_project_command.rs
index c0093e8..d4b4a1a 100644
--- a/crates/shirabe/src/command/create_project_command.rs
+++ b/crates/shirabe/src/command/create_project_command.rs
@@ -728,14 +728,10 @@ impl CreateProjectCommand {
             // TODO(phase-b): default_repos needs &mut RepositoryManager but we hold &RepositoryManager.
             let _ = rm;
             repository_set.add_repository(Box::new(CompositeRepository::new(
-                RepositoryFactory::default_repos(
-                    Some(io),
-                    Some(std::rc::Rc::clone(&config)),
-                    None,
-                )?
-                .into_iter()
-                .map(|(_, v)| v)
-                .collect(),
+                RepositoryFactory::default_repos(Some(io), Some(config.clone()), None)?
+                    .into_iter()
+                    .map(|(_, v)| v)
+                    .collect(),
             )));
         } else {
             for repo in repositories.unwrap() {
diff --git a/crates/shirabe/src/command/diagnose_command.rs b/crates/shirabe/src/command/diagnose_command.rs
index e721e52..7a16699 100644
--- a/crates/shirabe/src/command/diagnose_command.rs
+++ b/crates/shirabe/src/command/diagnose_command.rs
@@ -856,10 +856,8 @@ impl DiagnoseCommand {
             return Ok(result);
         }
 
-        let mut versions_util = Versions::new(
-            std::rc::Rc::clone(config),
-            self.http_downloader.clone().unwrap(),
-        );
+        let mut versions_util =
+            Versions::new(config.clone(), self.http_downloader.clone().unwrap());
         let latest = match versions_util.get_latest(None) {
             Ok(Ok(l)) => l,
             Ok(Err(e)) => {
diff --git a/crates/shirabe/src/command/self_update_command.rs b/crates/shirabe/src/command/self_update_command.rs
index 8645ce1..80d8b01 100644
--- a/crates/shirabe/src/command/self_update_command.rs
+++ b/crates/shirabe/src/command/self_update_command.rs
@@ -135,10 +135,7 @@ impl SelfUpdateCommand {
             Factory::create_http_downloader(io, &config, indexmap::IndexMap::new())?,
         ));
 
-        let mut versions_util = Versions::new(
-            std::rc::Rc::clone(&config),
-            std::rc::Rc::clone(&http_downloader),
-        );
+        let mut versions_util = Versions::new(config.clone(), http_downloader.clone());
 
         // switch channel if requested
         let mut requested_channel: Option<String> = None;
diff --git a/crates/shirabe/src/command/status_command.rs b/crates/shirabe/src/command/status_command.rs
index 83a21b8..190884a 100644
--- a/crates/shirabe/src/command/status_command.rs
+++ b/crates/shirabe/src/command/status_command.rs
@@ -104,7 +104,7 @@ impl StatusCommand {
             .unwrap_or_else(|| std::rc::Rc::new(std::cell::RefCell::new(ProcessExecutor::new(io))));
         let mut guesser = VersionGuesser::new(
             composer.get_config(),
-            std::rc::Rc::clone(&process_executor),
+            process_executor.clone(),
             parser.clone(),
             Some(io_box.clone_box()),
         );
diff --git a/crates/shirabe/src/composer.rs b/crates/shirabe/src/composer.rs
index 9f420ef..2da4639 100644
--- a/crates/shirabe/src/composer.rs
+++ b/crates/shirabe/src/composer.rs
@@ -451,9 +451,7 @@ impl PartialComposerHandle {
     /// Downcast to a full Composer handle. PHP `$composer instanceof Composer`.
     pub fn as_full(&self) -> Option<ComposerHandle> {
         if self.0.borrow().is_full() {
-            Some(ComposerHandle::from_rc_unchecked(std::rc::Rc::clone(
-                &self.0,
-            )))
+            Some(ComposerHandle::from_rc_unchecked(self.0.clone()))
         } else {
             None
         }
@@ -507,7 +505,7 @@ impl ComposerHandle {
     }
 
     pub fn upcast(&self) -> PartialComposerHandle {
-        PartialComposerHandle::from_rc(std::rc::Rc::clone(&self.0))
+        PartialComposerHandle::from_rc(self.0.clone())
     }
 
     pub fn downgrade(&self) -> ComposerWeakHandle {
diff --git a/crates/shirabe/src/dependency_resolver/decisions.rs b/crates/shirabe/src/dependency_resolver/decisions.rs
index 1fdc1d3..f0842d9 100644
--- a/crates/shirabe/src/dependency_resolver/decisions.rs
+++ b/crates/shirabe/src/dependency_resolver/decisions.rs
@@ -8,7 +8,7 @@ use shirabe_php_shim::LogicException;
 use std::fmt;
 
 pub struct Decisions {
-    pub(crate) pool: Pool,
+    pub(crate) pool: std::rc::Rc<std::cell::RefCell<Pool>>,
     pub(crate) decision_map: IndexMap<i64, i64>,
     pub(crate) decision_queue: Vec<(i64, Box<dyn Rule>)>,
     iterator_cursor: Option<usize>,
@@ -27,7 +27,7 @@ impl Decisions {
     pub const DECISION_LITERAL: usize = 0;
     pub const DECISION_REASON: usize = 1;
 
-    pub fn new(pool: Pool) -> Self {
+    pub fn new(pool: std::rc::Rc<std::cell::RefCell<Pool>>) -> Self {
         Self {
             pool,
             decision_map: IndexMap::new(),
@@ -187,10 +187,9 @@ impl Decisions {
 
         let previous_decision = self.decision_map.get(&package_id).copied().unwrap_or(0);
         if previous_decision != 0 {
-            let literal_string = self
-                .pool
-                .literal_to_pretty_string(literal, &IndexMap::new());
-            let package = self.pool.literal_to_package(literal);
+            let pool = self.pool.borrow();
+            let literal_string = pool.literal_to_pretty_string(literal, &IndexMap::new());
+            let package = pool.literal_to_package(literal);
             panic!(
                 "{}",
                 SolverBugException::new(format!(
diff --git a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
index 57d1d18..2d99d7f 100644
--- a/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_set_generator.rs
@@ -24,14 +24,17 @@ use crate::package::PackageInterface;
 #[derive(Debug)]
 pub struct RuleSetGenerator {
     pub(crate) policy: Box<dyn PolicyInterface>,
-    pub(crate) pool: Pool,
+    pub(crate) pool: std::rc::Rc<std::cell::RefCell<Pool>>,
     pub(crate) rules: RuleSet,
     pub(crate) added_map: IndexMap<i64, Box<dyn PackageInterface>>,
     pub(crate) added_packages_by_names: IndexMap<String, Vec<Box<dyn PackageInterface>>>,
 }
 
 impl RuleSetGenerator {
-    pub fn new(policy: Box<dyn PolicyInterface>, pool: Pool) -> Self {
+    pub fn new(
+        policy: Box<dyn PolicyInterface>,
+        pool: std::rc::Rc<std::cell::RefCell<Pool>>,
+    ) -> Self {
         Self {
             policy,
             pool,
@@ -221,6 +224,7 @@ impl RuleSetGenerator {
 
                 let possible_requires: Vec<Box<dyn PackageInterface>> = self
                     .pool
+                    .borrow_mut()
                     .what_provides(link.get_target(), Some(&*constraint))
                     .into_iter()
                     .map(|p| p.clone_package_box())
@@ -276,6 +280,7 @@ impl RuleSetGenerator {
 
                 let conflicts = self
                     .pool
+                    .borrow_mut()
                     .what_provides(link.get_target(), Some(&*constraint));
 
                 for conflict in &conflicts {
@@ -327,6 +332,7 @@ impl RuleSetGenerator {
                 // fixed package was not added to the pool as it did not pass the stability requirements, this is fine
                 if self
                     .pool
+                    .borrow()
                     .is_unacceptable_fixed_or_locked_package(package.as_ref())
                 {
                     continue;
@@ -373,6 +379,7 @@ impl RuleSetGenerator {
 
             let packages: Vec<Box<dyn PackageInterface>> = self
                 .pool
+                .borrow_mut()
                 .what_provides(package_name, Some(&*constraint))
                 .into_iter()
                 .map(|p| p.clone_package_box())
@@ -412,6 +419,7 @@ impl RuleSetGenerator {
     ) {
         let packages: Vec<Box<dyn BasePackage>> = self
             .pool
+            .borrow()
             .get_packages()
             .iter()
             .map(|p| p.clone_box())
diff --git a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
index 639061d..6c41e62 100644
--- a/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
+++ b/crates/shirabe/src/dependency_resolver/rule_watch_graph.rs
@@ -44,7 +44,7 @@ impl RuleWatchGraph {
                 self.watch_chains
                     .get_mut(&literal)
                     .unwrap()
-                    .unshift(std::rc::Rc::clone(&node));
+                    .unshift(node.clone());
             }
         } else {
             let literals: Vec<i64> = node.borrow().get_rule().get_literals().clone();
@@ -55,7 +55,7 @@ impl RuleWatchGraph {
                 self.watch_chains
                     .get_mut(&literal)
                     .unwrap()
-                    .unshift(std::rc::Rc::clone(&node));
+                    .unshift(node.clone());
             }
         }
     }
diff --git a/crates/shirabe/src/dependency_resolver/solver.rs b/crates/shirabe/src/dependency_resolver/solver.rs
index f9721f8..fd30165 100644
--- a/crates/shirabe/src/dependency_resolver/solver.rs
+++ b/crates/shirabe/src/dependency_resolver/solver.rs
@@ -31,7 +31,7 @@ use crate::package::BasePackage;
 #[derive(Debug)]
 pub struct Solver {
     pub(crate) policy: Box<dyn PolicyInterface>,
-    pub(crate) pool: Pool,
+    pub(crate) pool: std::rc::Rc<std::cell::RefCell<Pool>>,
 
     pub(crate) rules: RuleSet,
 
@@ -55,17 +55,18 @@ impl Solver {
     const BRANCH_LITERALS: usize = 0;
     const BRANCH_LEVEL: usize = 1;
 
-    pub fn new(policy: Box<dyn PolicyInterface>, pool: Pool, io: Box<dyn IOInterface>) -> Self {
+    pub fn new(
+        policy: Box<dyn PolicyInterface>,
+        pool: std::rc::Rc<std::cell::RefCell<Pool>>,
+        io: Box<dyn IOInterface>,
+    ) -> Self {
+        let decisions = Decisions::new(pool.clone());
         Self {
             policy,
             pool,
             rules: RuleSet::new(),
             watch_graph: RuleWatchGraph::new(),
-            // TODO(phase-b): PHP shares `$pool` between Solver and Decisions by reference.
-            // Pool has no `Default`/`Clone` impl, so we leave this placeholder until the
-            // resolver is refactored to use `Rc<RefCell<Pool>>`. `solve()` rebuilds the
-            // decisions field before any access.
-            decisions: todo!("Decisions::new requires a shared Pool reference"),
+            decisions,
             fixed_map: IndexMap::new(),
             propagate_index: 0,
             branches: Vec::new(),
@@ -81,8 +82,8 @@ impl Solver {
         self.rules.count()
     }
 
-    pub fn get_pool(&self) -> &Pool {
-        &self.pool
+    pub fn get_pool(&self) -> std::rc::Rc<std::cell::RefCell<Pool>> {
+        self.pool.clone()
     }
 
     // aka solver_makeruledecisions
@@ -213,6 +214,7 @@ impl Solver {
 
             if self
                 .pool
+                .borrow_mut()
                 .what_provides(package_name, Some(active_constraint))
                 .is_empty()
             {
@@ -252,20 +254,15 @@ impl Solver {
 
         self.io
             .write_error3("Generating rules", true, crate::io::DEBUG);
-        // TODO(phase-b): Pool is a PHP class without Clone; RuleSetGenerator should hold
-        // a shared reference (Rc<RefCell<Pool>>). Using a placeholder pool until then.
-        let mut rule_set_generator = RuleSetGenerator::new(
-            self.policy.clone_box(),
-            todo!("share Pool with RuleSetGenerator"),
-        );
+        let mut rule_set_generator =
+            RuleSetGenerator::new(self.policy.clone_box(), self.pool.clone());
         // TODO(phase-b): get_rules_for takes Option<Box<dyn PlatformRequirementFilterInterface>>;
         // PHP passes the filter directly. Forwarding `None` here keeps the call typecheckable.
         let _ = platform_requirement_filter.as_ref();
         self.rules = rule_set_generator.get_rules_for(request, None)?;
         drop(rule_set_generator);
         self.check_for_root_require_problems(request, platform_requirement_filter.as_ref());
-        // TODO(phase-b): Pool sharing — same as above.
-        self.decisions = Decisions::new(todo!("share Pool with Decisions"));
+        self.decisions = Decisions::new(self.pool.clone());
         self.watch_graph = RuleWatchGraph::new();
 
         // TODO(phase-b): RuleSet does not expose `iter()`; RuleWatchNode expects
@@ -306,7 +303,7 @@ impl Solver {
         // and borrows Pool/Decisions. The present/fixed maps from Request are keyed
         // by BasePackage; converting requires reworking Request.
         Ok(LockTransaction::new(
-            &self.pool,
+            &*self.pool.borrow(),
             todo!("convert request.get_present_map(false) to PackageInterface map"),
             todo!("convert request.get_fixed_packages_map() to PackageInterface map"),
             &self.decisions,
@@ -435,7 +432,7 @@ impl Solver {
     ) -> anyhow::Result<i64> {
         // choose best package to install from decisionQueue
         let mut literals = self.policy.select_preferred_packages(
-            &self.pool,
+            &*self.pool.borrow(),
             decision_queue,
             rule.get_required_package(),
         );
diff --git a/crates/shirabe/src/downloader/file_downloader.rs b/crates/shirabe/src/downloader/file_downloader.rs
index 4d33370..ce5d275 100644
--- a/crates/shirabe/src/downloader/file_downloader.rs
+++ b/crates/shirabe/src/downloader/file_downloader.rs
@@ -65,7 +65,7 @@ pub struct FileDownloader {
     /// @var Filesystem
     pub(crate) filesystem: std::rc::Rc<std::cell::RefCell<Filesystem>>,
     /// @var ?Cache
-    pub(crate) cache: Option<Cache>,
+    pub(crate) cache: Option<std::rc::Rc<std::cell::RefCell<Cache>>>,
     /// @var ?EventDispatcher
     pub(crate) event_dispatcher: Option<std::rc::Rc<std::cell::RefCell<EventDispatcher>>>,
     /// @var ProcessExecutor
@@ -93,7 +93,7 @@ impl FileDownloader {
         config: std::rc::Rc<std::cell::RefCell<Config>>,
         http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
         event_dispatcher: Option<std::rc::Rc<std::cell::RefCell<EventDispatcher>>>,
-        cache: Option<Cache>,
+        cache: Option<std::rc::Rc<std::cell::RefCell<Cache>>>,
         filesystem: Option<std::rc::Rc<std::cell::RefCell<Filesystem>>>,
         process: Option<std::rc::Rc<std::cell::RefCell<ProcessExecutor>>>,
     ) -> Self {
@@ -104,7 +104,7 @@ impl FileDownloader {
         });
         let filesystem = filesystem.unwrap_or_else(|| {
             std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(Some(
-                std::rc::Rc::clone(&process),
+                process.clone(),
             ))))
         });
 
@@ -120,10 +120,10 @@ impl FileDownloader {
             additional_cleanup_paths: IndexMap::new(),
         };
 
-        if this.cache.is_some() && this.cache.as_ref().unwrap().gc_is_necessary() {
+        if this.cache.is_some() && this.cache.as_ref().unwrap().borrow().gc_is_necessary() {
             // PHP: writeError('Running cache garbage collection', true, io_interface::VERY_VERBOSE)
             this.io.write_error("Running cache garbage collection");
-            this.cache.as_mut().unwrap().gc(
+            this.cache.as_ref().unwrap().borrow_mut().gc(
                 this.config
                     .borrow_mut()
                     .get("cache-files-ttl")
@@ -496,7 +496,7 @@ impl FileDownloader {
                 .get(package.get_name())
                 .unwrap()
                 .clone();
-            self.cache.as_mut().unwrap().remove(&key);
+            self.cache.as_ref().unwrap().borrow_mut().remove(&key);
             self.last_cache_writes.shift_remove(package.get_name());
         }
     }
diff --git a/crates/shirabe/src/downloader/git_downloader.rs b/crates/shirabe/src/downloader/git_downloader.rs
index 668a5e9..9c4c64d 100644
--- a/crates/shirabe/src/downloader/git_downloader.rs
+++ b/crates/shirabe/src/downloader/git_downloader.rs
@@ -45,9 +45,9 @@ impl GitDownloader {
         let inner = VcsDownloaderBase::new(io, config, process, fs);
         let git_util = GitUtil::new(
             inner.io.clone_box(),
-            std::rc::Rc::clone(&inner.config),
-            std::rc::Rc::clone(&inner.process),
-            std::rc::Rc::clone(&inner.filesystem),
+            inner.config.clone(),
+            inner.process.clone(),
+            inner.filesystem.clone(),
         );
         Self {
             inner,
diff --git a/crates/shirabe/src/downloader/gzip_downloader.rs b/crates/shirabe/src/downloader/gzip_downloader.rs
index 9a6a258..557fe3a 100644
--- a/crates/shirabe/src/downloader/gzip_downloader.rs
+++ b/crates/shirabe/src/downloader/gzip_downloader.rs
@@ -32,7 +32,7 @@ impl GzipDownloader {
         config: std::rc::Rc<std::cell::RefCell<Config>>,
         http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
         event_dispatcher: Option<std::rc::Rc<std::cell::RefCell<EventDispatcher>>>,
-        cache: Option<Cache>,
+        cache: Option<std::rc::Rc<std::cell::RefCell<Cache>>>,
         filesystem: std::rc::Rc<std::cell::RefCell<Filesystem>>,
         process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
     ) -> Self {
diff --git a/crates/shirabe/src/downloader/path_downloader.rs b/crates/shirabe/src/downloader/path_downloader.rs
index 126b521..9003e81 100644
--- a/crates/shirabe/src/downloader/path_downloader.rs
+++ b/crates/shirabe/src/downloader/path_downloader.rs
@@ -44,7 +44,7 @@ impl PathDownloader {
         config: std::rc::Rc<std::cell::RefCell<Config>>,
         http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
         event_dispatcher: Option<std::rc::Rc<std::cell::RefCell<EventDispatcher>>>,
-        cache: Option<Cache>,
+        cache: Option<std::rc::Rc<std::cell::RefCell<Cache>>>,
         filesystem: std::rc::Rc<std::cell::RefCell<Filesystem>>,
         process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
     ) -> Self {
@@ -389,8 +389,8 @@ impl PathDownloader {
         let path = Filesystem::trim_trailing_slash(path);
         let parser = VersionParser::new();
         let mut guesser = VersionGuesser::new(
-            std::rc::Rc::clone(&self.inner.config),
-            std::rc::Rc::clone(&self.inner.process),
+            self.inner.config.clone(),
+            self.inner.process.clone(),
             parser.clone(),
             Some(self.inner.io.clone_box()),
         );
diff --git a/crates/shirabe/src/downloader/perforce_downloader.rs b/crates/shirabe/src/downloader/perforce_downloader.rs
index 02e32b4..433ae8f 100644
--- a/crates/shirabe/src/downloader/perforce_downloader.rs
+++ b/crates/shirabe/src/downloader/perforce_downloader.rs
@@ -103,7 +103,7 @@ impl PerforceDownloader {
             repo_config.unwrap_or_default(),
             url,
             path,
-            std::rc::Rc::clone(&self.inner.process),
+            self.inner.process.clone(),
             self.inner.io.clone_box(),
         ));
     }
diff --git a/crates/shirabe/src/downloader/phar_downloader.rs b/crates/shirabe/src/downloader/phar_downloader.rs
index c805bb3..ee87bd1 100644
--- a/crates/shirabe/src/downloader/phar_downloader.rs
+++ b/crates/shirabe/src/downloader/phar_downloader.rs
@@ -28,7 +28,7 @@ impl PharDownloader {
         config: std::rc::Rc<std::cell::RefCell<Config>>,
         http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
         event_dispatcher: Option<std::rc::Rc<std::cell::RefCell<EventDispatcher>>>,
-        cache: Option<Cache>,
+        cache: Option<std::rc::Rc<std::cell::RefCell<Cache>>>,
         filesystem: std::rc::Rc<std::cell::RefCell<Filesystem>>,
         process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
     ) -> Self {
diff --git a/crates/shirabe/src/downloader/rar_downloader.rs b/crates/shirabe/src/downloader/rar_downloader.rs
index d798664..fd45c7d 100644
--- a/crates/shirabe/src/downloader/rar_downloader.rs
+++ b/crates/shirabe/src/downloader/rar_downloader.rs
@@ -31,7 +31,7 @@ impl RarDownloader {
         config: std::rc::Rc<std::cell::RefCell<Config>>,
         http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
         event_dispatcher: Option<std::rc::Rc<std::cell::RefCell<EventDispatcher>>>,
-        cache: Option<Cache>,
+        cache: Option<std::rc::Rc<std::cell::RefCell<Cache>>>,
         filesystem: std::rc::Rc<std::cell::RefCell<Filesystem>>,
         process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
     ) -> Self {
diff --git a/crates/shirabe/src/downloader/svn_downloader.rs b/crates/shirabe/src/downloader/svn_downloader.rs
index 56eb891..fc5bca7 100644
--- a/crates/shirabe/src/downloader/svn_downloader.rs
+++ b/crates/shirabe/src/downloader/svn_downloader.rs
@@ -47,8 +47,8 @@ impl SvnDownloader {
         let mut util = SvnUtil::new(
             url.to_string(),
             self.inner.io.clone_box(),
-            std::rc::Rc::clone(&self.inner.config),
-            Some(std::rc::Rc::clone(&self.inner.process)),
+            self.inner.config.clone(),
+            Some(self.inner.process.clone()),
         );
         if util.binary_version().is_none() {
             return Err(RuntimeException {
@@ -129,8 +129,8 @@ impl SvnDownloader {
         let mut util = SvnUtil::new(
             url.to_string(),
             self.inner.io.clone_box(),
-            std::rc::Rc::clone(&self.inner.config),
-            Some(std::rc::Rc::clone(&self.inner.process)),
+            self.inner.config.clone(),
+            Some(self.inner.process.clone()),
         );
         let mut flags: Vec<String> = vec![];
         if version_compare(&util.binary_version().unwrap_or_default(), "1.7.0", ">=") {
@@ -189,8 +189,8 @@ impl SvnDownloader {
         let mut util = SvnUtil::new(
             base_url.to_string(),
             self.inner.io.clone_box(),
-            std::rc::Rc::clone(&self.inner.config),
-            Some(std::rc::Rc::clone(&self.inner.process)),
+            self.inner.config.clone(),
+            Some(self.inner.process.clone()),
         );
         util.set_cache_credentials(self.cache_credentials);
         util.execute(command, url, cwd, path, self.inner.io.is_verbose())
@@ -384,8 +384,8 @@ impl SvnDownloader {
             let mut util = SvnUtil::new(
                 base_url,
                 self.inner.io.clone_box(),
-                std::rc::Rc::clone(&self.inner.config),
-                Some(std::rc::Rc::clone(&self.inner.process)),
+                self.inner.config.clone(),
+                Some(self.inner.process.clone()),
             );
             util.set_cache_credentials(self.cache_credentials);
             util.execute_local(command.clone(), path, None, self.inner.io.is_verbose())
diff --git a/crates/shirabe/src/downloader/tar_downloader.rs b/crates/shirabe/src/downloader/tar_downloader.rs
index a21e94d..b98b274 100644
--- a/crates/shirabe/src/downloader/tar_downloader.rs
+++ b/crates/shirabe/src/downloader/tar_downloader.rs
@@ -28,7 +28,7 @@ impl TarDownloader {
         config: std::rc::Rc<std::cell::RefCell<Config>>,
         http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
         event_dispatcher: Option<std::rc::Rc<std::cell::RefCell<EventDispatcher>>>,
-        cache: Option<Cache>,
+        cache: Option<std::rc::Rc<std::cell::RefCell<Cache>>>,
         filesystem: std::rc::Rc<std::cell::RefCell<Filesystem>>,
         process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
     ) -> Self {
diff --git a/crates/shirabe/src/downloader/vcs_downloader.rs b/crates/shirabe/src/downloader/vcs_downloader.rs
index 1f041bd..31f4c7c 100644
--- a/crates/shirabe/src/downloader/vcs_downloader.rs
+++ b/crates/shirabe/src/downloader/vcs_downloader.rs
@@ -447,8 +447,8 @@ pub trait VcsDownloader:
     fn get_vcs_reference(&self, package: &dyn PackageInterface, path: &str) -> Option<String> {
         let parser = VersionParser::new();
         let guesser = VersionGuesser::new(
-            std::rc::Rc::clone(self.config()),
-            std::rc::Rc::clone(self.process()),
+            self.config().clone(),
+            self.process().clone(),
             parser.clone(),
             Some(self.io().clone_box()),
         );
diff --git a/crates/shirabe/src/downloader/xz_downloader.rs b/crates/shirabe/src/downloader/xz_downloader.rs
index e90b263..7724e9a 100644
--- a/crates/shirabe/src/downloader/xz_downloader.rs
+++ b/crates/shirabe/src/downloader/xz_downloader.rs
@@ -27,7 +27,7 @@ impl XzDownloader {
         config: std::rc::Rc<std::cell::RefCell<Config>>,
         http_downloader: std::rc::Rc<std::cell::RefCell<HttpDownloader>>,
         event_dispatcher: Option<std::rc::Rc<std::cell::RefCell<EventDispatcher>>>,
-        cache: Option<Cache>,
+        cache: Option<std::rc::Rc<std::cell::RefCell<Cache>>>,
         filesystem: std::rc::Rc<std::cell::RefCell<Filesystem>>,
         process: std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
     ) -> Self {
diff --git a/crates/shirabe/src/downloader/zip_downloader.rs b/crates/shirabe/src/downloader/zip_downloader.rs
index 7cd5000..c51a9ea 100644
--- a/crates/shirabe/src/downloader/zip_downloader.rs
+++ b/crates/shirabe/src/downloader/zip_downloader.rs
@@ -39,7 +39,7 @@ impl ZipDownloader {
         event_dispatcher: Option<
             std::rc::Rc<std::cell::RefCell<crate::event_dispatcher::EventDispatcher>>,
         >,
-        cache: Option<crate::cache::Cache>,
+        cache: Option<std::rc::Rc<std::cell::RefCell<crate::cache::Cache>>>,
         filesystem: std::rc::Rc<std::cell::RefCell<crate::util::Filesystem>>,
         process: std::rc::Rc<std::cell::RefCell<crate::util::ProcessExecutor>>,
     ) -> Self {
diff --git a/crates/shirabe/src/factory.rs b/crates/shirabe/src/factory.rs
index 3e26416..35afd5d 100644
--- a/crates/shirabe/src/factory.rs
+++ b/crates/shirabe/src/factory.rs
@@ -587,7 +587,7 @@ impl Factory {
                     } else {
                         PartialOrFullComposer::new_partial()
                     };
-                    composer.set_config(std::rc::Rc::clone(&config));
+                    composer.set_config(config.clone());
                     if is_global {
                         composer.set_global();
                     }
@@ -625,8 +625,8 @@ impl Factory {
                         Some(io.clone_box()),
                     )));
                     let r#loop = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(
-                        std::rc::Rc::clone(&http_downloader),
-                        Some(std::rc::Rc::clone(&process)),
+                        http_downloader.clone(),
+                        Some(process.clone()),
                     )));
                     composer.set_loop(r#loop.clone());
 
@@ -635,20 +635,20 @@ impl Factory {
                         let mut d = EventDispatcher::new(
                             PartialComposerWeakHandle::from_weak(composer_weak.clone()),
                             io.clone_box(),
-                            Some(std::rc::Rc::clone(&process)),
+                            Some(process.clone()),
                         );
                         d.set_run_scripts(!disable_scripts);
                         std::rc::Rc::new(std::cell::RefCell::new(d))
                     };
-                    composer.set_event_dispatcher(std::rc::Rc::clone(&dispatcher));
+                    composer.set_event_dispatcher(dispatcher.clone());
 
                     // initialize repository manager
                     let rm = std::rc::Rc::new(std::cell::RefCell::new(RepositoryFactory::manager(
                         io,
                         &config,
-                        Some(std::rc::Rc::clone(&http_downloader)),
-                        Some(std::rc::Rc::clone(&dispatcher)),
-                        Some(std::rc::Rc::clone(&process)),
+                        Some(http_downloader.clone()),
+                        Some(dispatcher.clone()),
+                        Some(process.clone()),
                     )?));
 
                     // force-set the version of the global package if not defined as
@@ -661,14 +661,14 @@ impl Factory {
                     // load package
                     let parser = VersionParser::new();
                     let guesser = VersionGuesser::new(
-                        std::rc::Rc::clone(&config),
-                        std::rc::Rc::clone(&process),
+                        config.clone(),
+                        process.clone(),
                         parser.clone(),
                         Some(io.clone_box()),
                     );
                     let mut loader = self.load_root_package(
-                        std::rc::Rc::clone(&rm),
-                        std::rc::Rc::clone(&config),
+                        rm.clone(),
+                        config.clone(),
                         parser,
                         guesser,
                         io.clone_box(),
@@ -693,17 +693,17 @@ impl Factory {
                         composer.get_package(),
                         Some(&process),
                     );
-                    composer.set_repository_manager(std::rc::Rc::clone(&rm));
+                    composer.set_repository_manager(rm.clone());
 
                     // initialize installation manager
                     let im = std::rc::Rc::new(std::cell::RefCell::new(
                         self.create_installation_manager(
                             r#loop.clone(),
                             io.clone_box(),
-                            Some(std::rc::Rc::clone(&dispatcher)),
+                            Some(dispatcher.clone()),
                         ),
                     ));
-                    composer.set_installation_manager(std::rc::Rc::clone(&im));
+                    composer.set_installation_manager(im.clone());
 
                     if let PartialOrFullComposer::Full(ref mut composer_full) = composer {
                         // initialize download manager
@@ -717,10 +717,8 @@ impl Factory {
                         composer_full.set_download_manager(dm.clone());
 
                         // initialize autoload generator
-                        let generator = AutoloadGenerator::new(
-                            std::rc::Rc::clone(&dispatcher),
-                            Some(io.clone_box()),
-                        );
+                        let generator =
+                            AutoloadGenerator::new(dispatcher.clone(), Some(io.clone_box()));
                         composer_full.set_autoload_generator(std::rc::Rc::new(
                             std::cell::RefCell::new(generator),
                         ));
@@ -765,9 +763,9 @@ impl Factory {
                                     None,
                                     Some(io.clone_box()),
                                 )?,
-                                std::rc::Rc::clone(&im),
+                                im.clone(),
                                 &file_get_contents(composer_file_path).unwrap_or_default(),
-                                std::rc::Rc::clone(&process),
+                                process.clone(),
                             );
                             composer_full
                                 .set_locker(std::rc::Rc::new(std::cell::RefCell::new(locker)));
@@ -788,9 +786,9 @@ impl Factory {
                                     None,
                                     Some(io.clone_box()),
                                 )?,
-                                std::rc::Rc::clone(&im),
+                                im.clone(),
                                 &lock_contents,
-                                std::rc::Rc::clone(&process),
+                                process.clone(),
                             );
                             composer_full
                                 .set_locker(std::rc::Rc::new(std::cell::RefCell::new(locker)));
@@ -876,11 +874,8 @@ impl Factory {
         root_package: &dyn RootPackageInterface,
         process: Option<&std::rc::Rc<std::cell::RefCell<ProcessExecutor>>>,
     ) {
-        let fs = process.map(|p| {
-            std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(Some(
-                std::rc::Rc::clone(p),
-            ))))
-        });
+        let fs = process
+            .map(|p| std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(Some(p.clone())))));
 
         rm.set_local_repository(Box::new(
             InstalledFilesystemRepository::new(
@@ -947,31 +942,36 @@ impl Factory {
         process: &std::rc::Rc<std::cell::RefCell<ProcessExecutor>>,
         event_dispatcher: Option<&std::rc::Rc<std::cell::RefCell<EventDispatcher>>>,
     ) -> anyhow::Result<std::rc::Rc<std::cell::RefCell<DownloadManager>>> {
-        // TODO(phase-b): cache is shared across all downloaders; PHP class semantics requires
-        // either Rc<RefCell<Cache>> (with corresponding signature changes everywhere) or
-        // making Cache cloneable. For now we don't construct a cache and pass None below.
-        let _cache: Option<Cache> = None;
-        if config
+        let cache_files_ttl = config
             .borrow_mut()
             .get("cache-files-ttl")
             .and_then(|v| v.as_int())
-            .unwrap_or(0)
-            > 0
-        {
-            let _ = Cache::new(
+            .unwrap_or(0);
+        let cache = if cache_files_ttl > 0 {
+            let mut cache = Cache::new(
                 io.clone_box(),
                 &config.borrow_mut().get_str("cache-files-dir")?,
                 Some("a-z0-9_./"),
                 None,
                 false,
             );
-        }
+            cache.set_read_only(
+                config
+                    .borrow_mut()
+                    .get("cache-read-only")
+                    .and_then(|v| v.as_bool())
+                    .unwrap_or(false),
+            );
+            Some(std::rc::Rc::new(std::cell::RefCell::new(cache)))
+        } else {
+            None
+        };
 
         let fs = std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(Some(
-            std::rc::Rc::clone(process),
+            process.clone(),
         ))));
 
-        let mut dm = DownloadManager::new(io.clone_box(), false, Some(std::rc::Rc::clone(&fs)));
+        let mut dm = DownloadManager::new(io.clone_box(), false, Some(fs.clone()));
         let preferred = config.borrow_mut().get("preferred-install");
         match preferred.as_string() {
             Some("dist") => {
@@ -1006,141 +1006,141 @@ impl Factory {
             "git",
             Box::new(GitDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                Some(std::rc::Rc::clone(&process)),
-                Some(std::rc::Rc::clone(&fs)),
+                config.clone(),
+                Some(process.clone()),
+                Some(fs.clone()),
             )),
         );
         dm.set_downloader(
             "svn",
             Box::new(SvnDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(&process),
-                std::rc::Rc::clone(&fs),
+                config.clone(),
+                process.clone(),
+                fs.clone(),
             )),
         );
         dm.set_downloader(
             "fossil",
             Box::new(FossilDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(&process),
-                std::rc::Rc::clone(&fs),
+                config.clone(),
+                process.clone(),
+                fs.clone(),
             )),
         );
         dm.set_downloader(
             "hg",
             Box::new(HgDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(&process),
-                std::rc::Rc::clone(&fs),
+                config.clone(),
+                process.clone(),
+                fs.clone(),
             )),
         );
         dm.set_downloader(
             "perforce",
             Box::new(PerforceDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(&process),
-                std::rc::Rc::clone(&fs),
+                config.clone(),
+                process.clone(),
+                fs.clone(),
             )),
         );
         dm.set_downloader(
             "zip",
             Box::new(ZipDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(http_downloader),
+                config.clone(),
+                http_downloader.clone(),
                 event_dispatcher.cloned(),
-                None, // TODO(phase-b): shared Cache requires Rc<RefCell<Cache>>; see _cache
-                std::rc::Rc::clone(&fs),
-                std::rc::Rc::clone(&process),
+                cache.clone(),
+                fs.clone(),
+                process.clone(),
             )),
         );
         dm.set_downloader(
             "rar",
             Box::new(RarDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(http_downloader),
+                config.clone(),
+                http_downloader.clone(),
                 event_dispatcher.cloned(),
-                None, // TODO(phase-b): shared Cache requires Rc<RefCell<Cache>>; see _cache
-                std::rc::Rc::clone(&fs),
-                std::rc::Rc::clone(&process),
+                cache.clone(),
+                fs.clone(),
+                process.clone(),
             )),
         );
         dm.set_downloader(
             "tar",
             Box::new(TarDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(http_downloader),
+                config.clone(),
+                http_downloader.clone(),
                 event_dispatcher.cloned(),
-                None, // TODO(phase-b): shared Cache requires Rc<RefCell<Cache>>; see _cache
-                std::rc::Rc::clone(&fs),
-                std::rc::Rc::clone(&process),
+                cache.clone(),
+                fs.clone(),
+                process.clone(),
             )),
         );
         dm.set_downloader(
             "gzip",
             Box::new(GzipDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(http_downloader),
+                config.clone(),
+                http_downloader.clone(),
                 event_dispatcher.cloned(),
-                None, // TODO(phase-b): shared Cache requires Rc<RefCell<Cache>>; see _cache
-                std::rc::Rc::clone(&fs),
-                std::rc::Rc::clone(&process),
+                cache.clone(),
+                fs.clone(),
+                process.clone(),
             )),
         );
         dm.set_downloader(
             "xz",
             Box::new(XzDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(http_downloader),
+                config.clone(),
+                http_downloader.clone(),
                 event_dispatcher.cloned(),
-                None, // TODO(phase-b): shared Cache requires Rc<RefCell<Cache>>; see _cache
-                std::rc::Rc::clone(&fs),
-                std::rc::Rc::clone(&process),
+                cache.clone(),
+                fs.clone(),
+                process.clone(),
             )),
         );
         dm.set_downloader(
             "phar",
             Box::new(PharDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(http_downloader),
+                config.clone(),
+                http_downloader.clone(),
                 event_dispatcher.cloned(),
-                None, // TODO(phase-b): shared Cache requires Rc<RefCell<Cache>>; see _cache
-                std::rc::Rc::clone(&fs),
-                std::rc::Rc::clone(&process),
+                cache.clone(),
+                fs.clone(),
+                process.clone(),
             )),
         );
         dm.set_downloader(
             "file",
             Box::new(FileDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(http_downloader),
+                config.clone(),
+                http_downloader.clone(),
                 event_dispatcher.cloned(),
-                None, // TODO(phase-b): shared Cache requires Rc<RefCell<Cache>>; see _cache
-                Some(std::rc::Rc::clone(&fs)),
-                Some(std::rc::Rc::clone(&process)),
+                cache.clone(),
+                Some(fs.clone()),
+                Some(process.clone()),
             )),
         );
         dm.set_downloader(
             "path",
             Box::new(PathDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
-                std::rc::Rc::clone(http_downloader),
+                config.clone(),
+                http_downloader.clone(),
                 event_dispatcher.cloned(),
-                None, // TODO(phase-b): shared Cache requires Rc<RefCell<Cache>>; see _cache
-                std::rc::Rc::clone(&fs),
-                std::rc::Rc::clone(&process),
+                cache.clone(),
+                fs.clone(),
+                process.clone(),
             )),
         );
 
@@ -1223,7 +1223,7 @@ impl Factory {
             io.clone_box(),
             bin_dir.clone(),
             bin_compat.clone(),
-            Some(std::rc::Rc::clone(&fs)),
+            Some(fs.clone()),
             Some(vendor_dir.clone()),
         );
 
@@ -1367,7 +1367,7 @@ impl Factory {
         }
         let http_downloader_result: anyhow::Result<HttpDownloader> = Ok(HttpDownloader::new(
             io.clone_box(),
-            std::rc::Rc::clone(config),
+            config.clone(),
             http_downloader_options,
             disable_tls,
         ));
diff --git a/crates/shirabe/src/installer.rs b/crates/shirabe/src/installer.rs
index 8ea0249..3ccb65f 100644
--- a/crates/shirabe/src/installer.rs
+++ b/crates/shirabe/src/installer.rs
@@ -420,7 +420,7 @@ impl Installer {
 
         if self.install && self.execute_operations {
             // force binaries re-generation in case they are missing
-            let repository_manager = std::rc::Rc::clone(&self.repository_manager);
+            let repository_manager = self.repository_manager.clone();
             let repository_manager = repository_manager.borrow();
             for package in repository_manager.get_local_repository().get_packages() {
                 self.installation_manager
@@ -440,7 +440,7 @@ impl Installer {
 
         if show_funding {
             let mut funding_count: i64 = 0;
-            let repository_manager = std::rc::Rc::clone(&self.repository_manager);
+            let repository_manager = self.repository_manager.clone();
             let repository_manager = repository_manager.borrow();
             for package in repository_manager.get_local_repository().get_packages() {
                 if let Some(cp) = package.as_complete_package_interface() {
@@ -507,7 +507,7 @@ impl Installer {
                     IndexMap::new(),
                     IndexMap::new(),
                 );
-                let repository_manager = std::rc::Rc::clone(&self.repository_manager);
+                let repository_manager = self.repository_manager.clone();
                 let repository_manager = repository_manager.borrow();
                 for repo in repository_manager.get_repositories() {
                     repo_set.add_repository(repo.clone_box())?;
@@ -612,7 +612,7 @@ impl Installer {
         // creating repository set
         let policy = self.create_policy(true, locked_repository.as_ref());
         let mut repository_set = self.create_repository_set(true, &platform_repo, &aliases, None);
-        let repository_manager = std::rc::Rc::clone(&self.repository_manager);
+        let repository_manager = self.repository_manager.clone();
         let repository_manager = repository_manager.borrow();
         let repositories = repository_manager.get_repositories();
         for repository in repositories {
diff --git a/crates/shirabe/src/package/loader/root_package_loader.rs b/crates/shirabe/src/package/loader/root_package_loader.rs
index 5d66931..3cdaaa7 100644
--- a/crates/shirabe/src/package/loader/root_package_loader.rs
+++ b/crates/shirabe/src/package/loader/root_package_loader.rs
@@ -46,7 +46,7 @@ impl RootPackageLoader {
             let mut process_executor = ProcessExecutor::new(io.as_deref().map(|i| i.clone_box()));
             process_executor.enable_async();
             VersionGuesser::new(
-                std::rc::Rc::clone(&config),
+                config.clone(),
                 std::rc::Rc::new(std::cell::RefCell::new(process_executor)),
                 inner.version_parser.clone(),
                 io.as_ref().map(|i| i.clone_box()),
@@ -280,7 +280,7 @@ impl RootPackageLoader {
 
         let repos = RepositoryFactory::default_repos(
             None,
-            Some(std::rc::Rc::clone(&self.config)),
+            Some(self.config.clone()),
             Some(&mut *self.manager.borrow_mut()),
         )?;
         for (_, repo) in repos {
diff --git a/crates/shirabe/src/repository/composer_repository.rs b/crates/shirabe/src/repository/composer_repository.rs
index 772cedc..624c4a2 100644
--- a/crates/shirabe/src/repository/composer_repository.rs
+++ b/crates/shirabe/src/repository/composer_repository.rs
@@ -265,7 +265,7 @@ impl ComposerRepository {
         let loader = ArrayLoader::new(Some(version_parser.clone()), true);
 
         let r#loop = std::rc::Rc::new(std::cell::RefCell::new(Loop::new(
-            std::rc::Rc::clone(&http_downloader),
+            http_downloader.clone(),
             None,
         )));
 
@@ -2949,7 +2949,7 @@ impl ComposerRepository {
                     let mut dispatcher = dispatcher.borrow_mut();
                     let mut pre_file_download_event = PreFileDownloadEvent::new(
                         PluginEvents::PRE_FILE_DOWNLOAD.to_string(),
-                        std::rc::Rc::clone(&self.http_downloader),
+                        self.http_downloader.clone(),
                         filename.clone(),
                         "metadata".to_string(),
                         {
@@ -3144,7 +3144,7 @@ impl ComposerRepository {
                 let mut dispatcher = dispatcher.borrow_mut();
                 let mut pre_file_download_event = PreFileDownloadEvent::new(
                     PluginEvents::PRE_FILE_DOWNLOAD.to_string(),
-                    std::rc::Rc::clone(&self.http_downloader),
+                    self.http_downloader.clone(),
                     filename.clone(),
                     "metadata".to_string(),
                     {
@@ -3312,7 +3312,7 @@ impl ComposerRepository {
             let mut dispatcher = dispatcher.borrow_mut();
             let mut pre_file_download_event = PreFileDownloadEvent::new(
                 PluginEvents::PRE_FILE_DOWNLOAD.to_string(),
-                std::rc::Rc::clone(&self.http_downloader),
+                self.http_downloader.clone(),
                 filename.clone(),
                 "metadata".to_string(),
                 {
diff --git a/crates/shirabe/src/repository/path_repository.rs b/crates/shirabe/src/repository/path_repository.rs
index 7d37951..8d9965e 100644
--- a/crates/shirabe/src/repository/path_repository.rs
+++ b/crates/shirabe/src/repository/path_repository.rs
@@ -72,7 +72,7 @@ impl PathRepository {
         });
         let version_guesser = VersionGuesser::new(
             config,
-            std::rc::Rc::clone(&process),
+            process.clone(),
             VersionParser::new(),
             Some(io.clone_box()),
         );
diff --git a/crates/shirabe/src/repository/repository_factory.rs b/crates/shirabe/src/repository/repository_factory.rs
index 38e436b..0f2e6b2 100644
--- a/crates/shirabe/src/repository/repository_factory.rs
+++ b/crates/shirabe/src/repository/repository_factory.rs
@@ -206,7 +206,7 @@ impl RepositoryFactory {
 
         let mut rm = RepositoryManager::new(
             io,
-            std::rc::Rc::clone(config),
+            config.clone(),
             http_downloader,
             event_dispatcher,
             Some(process),
diff --git a/crates/shirabe/src/repository/vcs/forgejo_driver.rs b/crates/shirabe/src/repository/vcs/forgejo_driver.rs
index 18df35d..72fd6af 100644
--- a/crates/shirabe/src/repository/vcs/forgejo_driver.rs
+++ b/crates/shirabe/src/repository/vcs/forgejo_driver.rs
@@ -534,7 +534,7 @@ impl ForgejoDriver {
                 todo!("clone io for GitDriver setup"),
                 self.inner.config.clone(),
                 self.inner.http_downloader.clone(),
-                std::rc::Rc::clone(&self.inner.process),
+                self.inner.process.clone(),
             ),
             tags: None,
             branches: None,
diff --git a/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs b/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs
index 1cb7b46..19f0246 100644
--- a/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs
+++ b/crates/shirabe/src/repository/vcs/git_bitbucket_driver.rs
@@ -694,9 +694,9 @@ impl GitBitbucketDriver {
                 // TODO(phase-b): only handle TransportException
                 let mut bitbucket_util = Bitbucket::new(
                     self.inner.io.clone_box(),
-                    std::rc::Rc::clone(&self.inner.config),
-                    Some(std::rc::Rc::clone(&self.inner.process)),
-                    Some(std::rc::Rc::clone(&self.inner.http_downloader)),
+                    self.inner.config.clone(),
+                    Some(self.inner.process.clone()),
+                    Some(self.inner.http_downloader.clone()),
                     None,
                 )?;
 
diff --git a/crates/shirabe/src/repository/vcs/git_driver.rs b/crates/shirabe/src/repository/vcs/git_driver.rs
index 8c0aefd..69b16b6 100644
--- a/crates/shirabe/src/repository/vcs/git_driver.rs
+++ b/crates/shirabe/src/repository/vcs/git_driver.rs
@@ -118,8 +118,8 @@ impl GitDriver {
 
             let mut git_util = GitUtil::new(
                 self.inner.io.clone_box(),
-                std::rc::Rc::clone(&self.inner.config),
-                std::rc::Rc::clone(&self.inner.process),
+                self.inner.config.clone(),
+                self.inner.process.clone(),
                 std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None))),
             );
             if !git_util.sync_mirror(&self.inner.url, &self.repo_dir)? {
@@ -184,8 +184,8 @@ impl GitDriver {
 
             let mut git_util = GitUtil::new(
                 self.inner.io.clone_box(),
-                std::rc::Rc::clone(&self.inner.config),
-                std::rc::Rc::clone(&self.inner.process),
+                self.inner.config.clone(),
+                self.inner.process.clone(),
                 std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None))),
             );
             if !Filesystem::is_local_path(&self.inner.url) {
@@ -451,7 +451,7 @@ impl GitDriver {
         let mut git_util = GitUtil::new(
             io.clone_box(),
             todo!(),
-            std::rc::Rc::clone(&process),
+            process.clone(),
             std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(None))),
         );
         GitUtil::clean_env(&process);
diff --git a/crates/shirabe/src/repository/vcs/github_driver.rs b/crates/shirabe/src/repository/vcs/github_driver.rs
index c2207ee..6c8d495 100644
--- a/crates/shirabe/src/repository/vcs/github_driver.rs
+++ b/crates/shirabe/src/repository/vcs/github_driver.rs
@@ -1016,9 +1016,9 @@ impl GitHubDriver {
             Err(e) => {
                 let mut git_hub_util = GitHub::new(
                     self.inner.io.clone_box(),
-                    std::rc::Rc::clone(&self.inner.config),
-                    Some(std::rc::Rc::clone(&self.inner.process)),
-                    Some(std::rc::Rc::clone(&self.inner.http_downloader)),
+                    self.inner.config.clone(),
+                    Some(self.inner.process.clone()),
+                    Some(self.inner.http_downloader.clone()),
                 )
                 .map_err(|err| TransportException::new(err.to_string(), 0))?;
 
@@ -1296,8 +1296,8 @@ impl GitHubDriver {
             repo_config,
             self.inner.io.clone_box(),
             self.inner.config.clone(),
-            std::rc::Rc::clone(&self.inner.http_downloader),
-            std::rc::Rc::clone(&self.inner.process),
+            self.inner.http_downloader.clone(),
+            self.inner.process.clone(),
         );
         git_driver.initialize()?;
         self.git_driver = Some(git_driver);
diff --git a/crates/shirabe/src/repository/vcs/gitlab_driver.rs b/crates/shirabe/src/repository/vcs/gitlab_driver.rs
index 1966237..8a24b7d 100644
--- a/crates/shirabe/src/repository/vcs/gitlab_driver.rs
+++ b/crates/shirabe/src/repository/vcs/gitlab_driver.rs
@@ -770,8 +770,8 @@ impl GitLabDriver {
             repo_config,
             self.inner.io.clone_box(),
             self.inner.config.clone(),
-            std::rc::Rc::clone(&self.inner.http_downloader),
-            std::rc::Rc::clone(&self.inner.process),
+            self.inner.http_downloader.clone(),
+            self.inner.process.clone(),
         );
         git_driver.initialize()?;
         self.git_driver = Some(git_driver);
@@ -886,9 +886,9 @@ impl GitLabDriver {
             Err(e) => {
                 let mut git_lab_util = GitLab::new(
                     self.inner.io.clone_box(),
-                    std::rc::Rc::clone(&self.inner.config),
-                    Some(std::rc::Rc::clone(&self.inner.process)),
-                    Some(std::rc::Rc::clone(&self.inner.http_downloader)),
+                    self.inner.config.clone(),
+                    Some(self.inner.process.clone()),
+                    Some(self.inner.http_downloader.clone()),
                 )
                 .map_err(|err| TransportException::new(err.to_string(), 0))?;
 
diff --git a/crates/shirabe/src/repository/vcs/perforce_driver.rs b/crates/shirabe/src/repository/vcs/perforce_driver.rs
index 0bd6d12..35da517 100644
--- a/crates/shirabe/src/repository/vcs/perforce_driver.rs
+++ b/crates/shirabe/src/repository/vcs/perforce_driver.rs
@@ -76,7 +76,7 @@ impl PerforceDriver {
             repo_config.clone(),
             self.inner.url.clone(),
             repo_dir,
-            std::rc::Rc::clone(&self.inner.process),
+            self.inner.process.clone(),
             self.inner.io.clone_box(),
         ));
 
diff --git a/crates/shirabe/src/util/git.rs b/crates/shirabe/src/util/git.rs
index d8e11d9..f1b71f9 100644
--- a/crates/shirabe/src/util/git.rs
+++ b/crates/shirabe/src/util/git.rs
@@ -387,8 +387,8 @@ impl Git {
                 if !self.io.has_authentication(&m1) {
                     let mut git_hub_util = GitHub::new(
                         self.io.clone_box(),
-                        std::rc::Rc::clone(&self.config),
-                        Some(std::rc::Rc::clone(&self.process)),
+                        self.config.clone(),
+                        Some(self.process.clone()),
                         self.http_downloader.clone(),
                     )?;
                     let message = "Cloning failed using an ssh key for authentication, enter your GitHub credentials to access private repos";
@@ -449,8 +449,8 @@ impl Git {
                 // bitbucket either through oauth or app password, with fallback to ssh.
                 let mut bitbucket_util = Bitbucket::new(
                     self.io.clone_box(),
-                    std::rc::Rc::clone(&self.config),
-                    Some(std::rc::Rc::clone(&self.process)),
+                    self.config.clone(),
+                    Some(self.process.clone()),
                     self.http_downloader.clone(),
                     None,
                 )?;
@@ -614,8 +614,8 @@ impl Git {
                 if !self.io.has_authentication(&m2) {
                     let mut git_lab_util = GitLab::new(
                         self.io.clone_box(),
-                        std::rc::Rc::clone(&self.config),
-                        Some(std::rc::Rc::clone(&self.process)),
+                        self.config.clone(),
+                        Some(self.process.clone()),
                         self.http_downloader.clone(),
                     )?;
                     let message =
@@ -768,7 +768,7 @@ impl Git {
                         self.io
                             .set_authentication(m2.clone(), username, Some(password));
                         let mut auth_helper =
-                            AuthHelper::new(self.io.clone_box(), std::rc::Rc::clone(&self.config));
+                            AuthHelper::new(self.io.clone_box(), self.config.clone());
                         let store_auth_enum = match &store_auth {
                             PhpMixed::String(s) if s == "prompt" => StoreAuth::Prompt,
                             PhpMixed::Bool(b) => StoreAuth::Bool(*b),
diff --git a/crates/shirabe/src/util/http_downloader.rs b/crates/shirabe/src/util/http_downloader.rs
index b5a4923..3072df2 100644
--- a/crates/shirabe/src/util/http_downloader.rs
+++ b/crates/shirabe/src/util/http_downloader.rs
@@ -124,7 +124,7 @@ impl HttpDownloader {
         let curl = if Self::is_curl_enabled() {
             Some(CurlDownloader::new(
                 io.clone_box(),
-                std::rc::Rc::clone(&config),
+                config.clone(),
                 options.clone(),
                 disable_tls,
             ))
@@ -134,7 +134,7 @@ impl HttpDownloader {
 
         let rfs = Some(RemoteFilesystem::new(
             io.clone_box(),
-            std::rc::Rc::clone(&config),
+            config.clone(),
             options.clone(),
             disable_tls,
             None,
diff --git a/crates/shirabe/src/util/perforce.rs b/crates/shirabe/src/util/perforce.rs
index 9c68cc9..10c426f 100644
--- a/crates/shirabe/src/util/perforce.rs
+++ b/crates/shirabe/src/util/perforce.rs
@@ -829,7 +829,7 @@ impl Perforce {
     pub fn get_filesystem(&mut self) -> &std::rc::Rc<std::cell::RefCell<Filesystem>> {
         if self.filesystem.is_none() {
             self.filesystem = Some(std::rc::Rc::new(std::cell::RefCell::new(Filesystem::new(
-                Some(std::rc::Rc::clone(&self.process)),
+                Some(self.process.clone()),
             ))));
         }