@@ -7,6 +7,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 ### Fixed
+- asimov-registry, asimov-installer: Reject executable collisions and invalid
+  binary entries, roll back failed registration/uninstall, and preserve links
+  reassigned to other modules during uninstall
 - asimov-module: Read and resolve installed module directories while retaining
   legacy manifest lookup, and support lookup from an explicit state root
 - asimov-installer: Stage upgrades before replacing working installations,
 
@@ -107,16 +107,10 @@ reproductions and build results are distinguished from source-review findings.
   final path segment without validating status or tag-route shape. Test failed
   redirects and asset fallback using injectable local release endpoints.
 
-- [ ] **Make executable registration ownership-aware and recoverable.**
-  `Registry::add_module` in `lib/asimov-registry/src/registry.rs` commits the
-  module directory before linking binaries, and `add_binary` removes an existing
-  destination without checking its owner. Uninstall in installer removes names
-  from the manifest regardless of their current targets. Preflight collisions,
-  validate executable entries, and roll back failed publication; test two
-  modules providing the same name and partial link failures.
-  Extend upgrade transaction locking to all registry mutations and recover
-  interrupted upgrades before general registry reads, not only upgrade retries.
-  Upgrade publication currently has a brief reader-visible directory/link gap;
+- [ ] **Coordinate low-level registry mutations and read-time recovery.**
+  Extend publication locking to legacy migration, enable/disable, and low-level
+  removal APIs. Recover interrupted publications before general registry reads.
+  Publication currently has a brief reader-visible directory/link gap;
   assess generation-based publication and power-loss durability separately.
 
 - [ ] **Make legacy registry migration atomic and observable.**
 
@@ -89,8 +89,9 @@ impl Installer {
     /// Stage a replacement before publishing it, preserving enabled state.
     ///
     /// Publication failures roll back the prior installation. An interrupted
-    /// publication is recovered on the next upgrade attempt. Callers must exclude
-    /// concurrent install/uninstall and enable/disable operations on the registry.
+    /// publication is recovered on the next registration, upgrade, or uninstall.
+    /// Publication shares a lock with registration and uninstall; callers must
+    /// exclude low-level registry mutations and enable/disable operations.
     ///
     /// ```rust,no_run
     /// # use asimov_installer::{Installer, InstallOptions};
@@ -134,19 +135,7 @@ impl Installer {
     }
 
     pub async fn uninstall_module(&self, module_name: &ModuleName) -> Result<(), UninstallError> {
-        let manifest = self.registry.read_manifest(module_name).await?;
-
-        self.registry.disable_module(module_name).await?;
-
-        for program in &manifest.manifest.provides.programs {
-            self.registry
-                .remove_binary(program)
-                .await
-                .map_err(|e| UninstallError::RemoveBinary(program.into(), e))?;
-        }
-
-        self.registry.remove_module(module_name).await?;
-
+        self.registry.uninstall_module(module_name).await?;
         Ok(())
     }
 
@@ -297,7 +286,7 @@ impl Installer {
     ) -> Result<(), FinishInstallError> {
         let (module_name, module_dir) = self.stage_install(preinstalled, work_dir).await?;
         self.registry
-            .add_module(&module_name, module_dir.path())
+            .add_module_owned(&module_name, module_dir)
             .await?;
         Ok(())
     }
 
@@ -44,6 +44,8 @@ pub enum UpgradeError {
 
 #[derive(Debug, Error)]
 pub enum UninstallError {
+    #[error("uninstall publication or recovery failed: {0}")]
+    Publication(#[from] io::Error),
     #[error("unable to read module manifest file: {0}")]
     Read(#[from] registry::ManifestError),
     #[error(transparent)]
 
@@ -8,6 +8,7 @@ use tokio::io;
 
 pub mod error;
 use error::*;
+mod registration;
 mod upgrade;
 
 pub use asimov_module::layout::MANIFEST_FILE_NAME;
@@ -86,47 +87,6 @@ impl Registry {
         self.install_dir.join(module_name.as_str())
     }
 
-    pub async fn add_module(
-        &self,
-        module_name: &ModuleName,
-        dir: impl AsRef<Path>,
-    ) -> Result<(), AddModuleError> {
-        if self.is_module_installed(module_name).await.unwrap_or(false) {
-            return Err(AddModuleError::AlreadyInstalled);
-        }
-
-        let module_dir = self.module_dir(module_name);
-
-        tokio::fs::rename(dir.as_ref(), &module_dir)
-            .await
-            .map_err(|e| AddModuleError::Install(dir.as_ref().into(), module_dir.clone(), e))?;
-
-        let bin_dir = module_dir.join(BIN_DIR_NAME);
-
-        let mut entries = match tokio::fs::read_dir(&bin_dir).await {
-            Ok(entries) => entries,
-            Err(err) if err.kind() == io::ErrorKind::NotFound => return Ok(()),
-            Err(err) => return Err(AddModuleError::ReadBinDir(bin_dir, err)),
-        };
-
-        while let Some(entry) = entries
-            .next_entry()
-            .await
-            .map_err(|e| AddModuleError::ReadBinDir(bin_dir.clone(), e))?
-        {
-            let program_name = entry.file_name();
-            let Some(program_name) = program_name.to_str() else {
-                continue;
-            };
-
-            self.add_binary(program_name, &entry.path())
-                .await
-                .map_err(|e| AddModuleError::AddBinary(program_name.into(), e))?;
-        }
-
-        Ok(())
-    }
-
     pub async fn read_manifest(
         &self,
         module_name: &ModuleName,
@@ -167,6 +127,9 @@ impl Registry {
             .map_err(Into::into)
     }
 
+    /// Remove only the module directory. Prefer [`Self::uninstall_module`] to
+    /// transactionally remove the directory and its owned links together.
+    /// This low-level operation must not overlap a publication transaction.
     pub async fn remove_module(&self, module_name: &ModuleName) -> Result<(), RemoveModuleError> {
         self.migrate_legacy_manifest(module_name).await;
 
@@ -181,22 +144,9 @@ impl Registry {
             .map_err(|e| RemoveModuleError::RemoveModuleDir(module_dir, e))
     }
 
-    async fn add_binary(&self, program_name: &str, binary_path: &Path) -> io::Result<()> {
-        let target_path = match self
-            .exec_dir
-            .parent()
-            .and_then(|parent| binary_path.strip_prefix(parent).ok())
-        {
-            Some(suffix) => PathBuf::from("..").join(suffix),
-            None => binary_path.into(),
-        };
-
-        let link_path = self.exec_dir.join(program_name);
-        let _ = self.remove_binary(program_name).await;
-
-        create_symlink(&target_path, &link_path, false).await
-    }
-
+    /// Unconditionally remove an executable entry, without checking ownership.
+    /// Prefer [`Self::uninstall_module`] when removing a module. This low-level
+    /// operation must not overlap a publication transaction.
     pub async fn remove_binary(&self, name: impl AsRef<str>) -> Result<(), RemoveBinaryError> {
         let name = name.as_ref();
 
 
@@ -15,6 +15,8 @@ pub enum CreateFileTreeError {
 
 #[derive(Debug, Error)]
 pub enum AddModuleError {
+    #[error("registration failed: {0}")]
+    Publication(#[from] io::Error),
     #[error("module is already installed")]
     AlreadyInstalled,
     #[error("failed to install module from `{0}` to `{1}`: {2}")]