refactor(workspace): consolidate crates into mozart-core

Merged mozart-archiver, mozart-autoload, mozart-registry,
mozart-sat-resolver, and mozart-vcs into mozart-core to align
the source layout with Composer's structure.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

102 files changed, 849 insertions, 1138 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 59e6c03..d929c13 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1088,15 +1088,11 @@ dependencies = [
  "clap_complete",
  "colored",
  "indexmap",
- "mozart-archiver",
- "mozart-autoload",
  "mozart-console-macros",
  "mozart-core",
- "mozart-registry",
  "mozart-semver",
  "mozart-spdx-licenses",
  "mozart-test-harness",
- "mozart-vcs",
  "predicates",
  "regex",
  "reqwest",
@@ -1113,37 +1109,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "mozart-archiver"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "bzip2",
- "flate2",
- "mozart-registry",
- "regex",
- "serde_json",
- "sha1",
- "tar",
- "tempfile",
- "zip",
-]
-
-[[package]]
-name = "mozart-autoload"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "indexmap",
- "md5",
- "mozart-class-map-generator",
- "mozart-core",
- "mozart-registry",
- "regex",
- "serde_json",
- "tempfile",
-]
-
-[[package]]
 name = "mozart-class-map-generator"
 version = "0.1.0"
 dependencies = [
@@ -1167,49 +1132,23 @@ name = "mozart-core"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "async-trait",
+ "base64",
+ "bzip2",
  "colored",
  "dialoguer",
- "indexmap",
- "mozart-console-macros",
- "mozart-spdx-licenses",
- "regex",
- "reqwest",
- "serde",
- "serde_json",
- "tempfile",
- "tracing",
-]
-
-[[package]]
-name = "mozart-metadata-minifier"
-version = "0.1.0"
-dependencies = [
- "serde_json",
-]
-
-[[package]]
-name = "mozart-php-serialize"
-version = "0.1.0"
-
-[[package]]
-name = "mozart-registry"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "async-trait",
  "filetime",
  "flate2",
  "indexmap",
  "md5",
+ "mozart-class-map-generator",
  "mozart-console-macros",
- "mozart-core",
  "mozart-metadata-minifier",
  "mozart-php-serialize",
- "mozart-sat-resolver",
  "mozart-semver",
- "mozart-test-harness",
- "mozart-vcs",
+ "mozart-spdx-licenses",
  "regex",
+ "reqwest",
  "serde",
  "serde_json",
  "sha1",
@@ -1217,19 +1156,22 @@ dependencies = [
  "tempfile",
  "tokio",
  "tracing",
+ "url",
  "zip",
 ]
 
 [[package]]
-name = "mozart-sat-resolver"
+name = "mozart-metadata-minifier"
 version = "0.1.0"
 dependencies = [
- "indexmap",
- "mozart-core",
- "mozart-semver",
+ "serde_json",
 ]
 
 [[package]]
+name = "mozart-php-serialize"
+version = "0.1.0"
+
+[[package]]
 name = "mozart-semver"
 version = "0.1.0"
 
@@ -1253,25 +1195,6 @@ dependencies = [
 ]
 
 [[package]]
-name = "mozart-vcs"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "base64",
- "indexmap",
- "mozart-core",
- "mozart-semver",
- "regex",
- "reqwest",
- "serde",
- "serde_json",
- "tempfile",
- "tokio",
- "tracing",
- "url",
-]
-
-[[package]]
 name = "normalize-line-endings"
 version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/Cargo.toml b/Cargo.toml
index 9aeca9f..1170b36 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,19 +7,14 @@ version = "0.1.0"
 edition = "2024"
 
 [workspace.dependencies]
-mozart-archiver = { path = "crates/mozart-archiver" }
-mozart-autoload = { path = "crates/mozart-autoload" }
 mozart-class-map-generator = { path = "crates/mozart-class-map-generator" }
-mozart-core = { path = "crates/mozart-core" }
 mozart-console-macros = { path = "crates/mozart-console-macros" }
+mozart-core = { path = "crates/mozart-core" }
 mozart-metadata-minifier = { path = "crates/mozart-metadata-minifier" }
 mozart-php-serialize = { path = "crates/mozart-php-serialize" }
-mozart-registry = { path = "crates/mozart-registry" }
-mozart-sat-resolver = { path = "crates/mozart-sat-resolver" }
 mozart-semver = { path = "crates/mozart-semver" }
 mozart-spdx-licenses = { path = "crates/mozart-spdx-licenses" }
 mozart-test-harness = { path = "crates/mozart-test-harness" }
-mozart-vcs = { path = "crates/mozart-vcs" }
 anyhow = "1.0.102"
 assert_cmd = "2.1.2"
 async-trait = "0.1.83"
diff --git a/crates/mozart-archiver/Cargo.toml b/crates/mozart-archiver/Cargo.toml
deleted file mode 100644
index 6e2dbfd..0000000
--- a/crates/mozart-archiver/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-name = "mozart-archiver"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-mozart-registry.workspace = true
-anyhow.workspace = true
-bzip2.workspace = true
-flate2.workspace = true
-regex.workspace = true
-serde_json.workspace = true
-sha1.workspace = true
-tar.workspace = true
-zip.workspace = true
-
-[dev-dependencies]
-tempfile.workspace = true
diff --git a/crates/mozart-autoload/Cargo.toml b/crates/mozart-autoload/Cargo.toml
deleted file mode 100644
index 571d70f..0000000
--- a/crates/mozart-autoload/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "mozart-autoload"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-mozart-class-map-generator.workspace = true
-mozart-core.workspace = true
-mozart-registry.workspace = true
-anyhow.workspace = true
-indexmap.workspace = true
-md5.workspace = true
-regex.workspace = true
-serde_json.workspace = true
-
-[dev-dependencies]
-tempfile.workspace = true
diff --git a/crates/mozart-autoload/src/dump.rs b/crates/mozart-autoload/src/dump.rs
deleted file mode 100644
index 103c683..0000000
--- a/crates/mozart-autoload/src/dump.rs
+++ /dev/null
@@ -1,340 +0,0 @@
-//! `Composer\Autoload\AutoloadGenerator::dump` extension.
-//!
-//! [`mozart_core::composer::AutoloadGenerator`] is a state container in
-//! `mozart-core`; the dumping algorithm itself sits here in
-//! `mozart-autoload` because it pulls in the classmap scanner,
-//! installed.json reader, and PHP-emission helpers. This module hangs
-//! `dump()` off the generator via [`AutoloadGeneratorExt`] so callers
-//! can still write `composer.autoload_generator().dump(...)`, matching
-//! `$composer->getAutoloadGenerator()->dump(...)` in PHP.
-//!
-//! Bring [`AutoloadGeneratorExt`] into scope at the call site:
-//!
-//! ```ignore
-//! use mozart_autoload::AutoloadGeneratorExt;
-//! ```
-//!
-//! See `Composer\Autoload\AutoloadGenerator::dump()` (the ~500-line
-//! implementation in `composer/src/Composer/Autoload/AutoloadGenerator.php`)
-//! for the upstream semantics.
-
-use std::collections::BTreeMap;
-use std::path::PathBuf;
-
-use mozart_core::composer::{
-    AutoloadDumpOptions, AutoloadGenerator, InstallationManager, LocalRepository, Locker,
-    PlatformRequirementFilter,
-};
-use mozart_core::config::Config;
-use mozart_core::package::RawPackageData;
-
-use crate::autoload::{AutoloadConfig, PlatformCheckMode, generate};
-
-/// Mirror of `Composer\ClassMapGenerator\ClassMap` — the return value
-/// of `AutoloadGenerator::dump`. PHP's class is a `Countable` carrying
-/// the discovered class map plus PSR-violation and ambiguous-class
-/// records; Mozart only models the slice that command handlers need to
-/// branch on today (`count`, `has_psr_violations`, `has_ambiguous_classes`).
-///
-/// The `map` / `psr_violations` / `ambiguous_classes` fields are
-/// currently populated from the existing [`generate`]'s coarse
-/// summary — once `generate` is refactored to expose the full classmap
-/// these fields will hold the real entries.
-pub struct ClassMap {
-    map: BTreeMap<String, String>,
-    psr_violations: Vec<String>,
-    ambiguous_classes: BTreeMap<String, Vec<String>>,
-}
-
-impl ClassMap {
-    /// Mirror of `ClassMap::count`.
-    pub fn count(&self) -> usize {
-        self.map.len()
-    }
-
-    /// Mirror of `count($classMap->getPsrViolations()) > 0`. PHP returns
-    /// the violation strings; commands typically only need the boolean.
-    pub fn has_psr_violations(&self) -> bool {
-        !self.psr_violations.is_empty()
-    }
-
-    /// Mirror of `count($classMap->getAmbiguousClasses($filter)) > 0`.
-    /// `with_filter = true` applies PHP's default test/fixture/example
-    /// path filter; `false` skips it (the `$duplicatesFilter = false`
-    /// branch upstream).
-    pub fn has_ambiguous_classes(&self, with_filter: bool) -> bool {
-        if !with_filter {
-            return !self.ambiguous_classes.is_empty();
-        }
-        let pattern = regex_filter_default();
-        self.ambiguous_classes.values().any(|paths| {
-            paths
-                .iter()
-                .any(|p| !pattern.is_match(&p.replace('\\', "/")))
-        })
-    }
-
-    /// Read access to the underlying map (`getMap()` upstream).
-    pub fn map(&self) -> &BTreeMap<String, String> {
-        &self.map
-    }
-
-    /// Read access to the PSR-violation warnings.
-    pub fn psr_violations(&self) -> &[String] {
-        &self.psr_violations
-    }
-
-    /// Read access to the ambiguous-class records.
-    pub fn ambiguous_classes(&self) -> &BTreeMap<String, Vec<String>> {
-        &self.ambiguous_classes
-    }
-}
-
-fn regex_filter_default() -> regex::Regex {
-    use std::sync::OnceLock;
-    static RE: OnceLock<regex::Regex> = OnceLock::new();
-    RE.get_or_init(|| {
-        // `{/(test|fixture|example|stub)s?/}i` from PHP's
-        // ClassMap::getAmbiguousClasses default.
-        regex::Regex::new(r"(?i)/(test|fixture|example|stub)s?/")
-            .expect("default ambiguous filter compiles")
-    })
-    .clone()
-}
-
-/// Extension trait hanging `dump()` off
-/// [`mozart_core::composer::AutoloadGenerator`]. Mirrors
-/// `Composer\Autoload\AutoloadGenerator::dump()`.
-///
-/// Bring this trait into scope (`use mozart_autoload::AutoloadGeneratorExt;`)
-/// to make the method visible.
-///
-/// Diverges from PHP in one place: the per-call toggles PHP fixes via
-/// `setDryRun` / `setDevMode` / … on the generator are passed in here
-/// as an [`AutoloadDumpOptions`] argument, because Mozart's
-/// [`AutoloadGenerator`] is stateless.
-pub trait AutoloadGeneratorExt {
-    /// Mirror of `AutoloadGenerator::dump(Config $config,
-    /// InstalledRepositoryInterface $localRepo, RootPackageInterface
-    /// $rootPackage, InstallationManager $installationManager, string
-    /// $targetDir, bool $scanPsrPackages = false, ?string $suffix = null,
-    /// ?Locker $locker = null, bool $strictAmbiguous = false)`.
-    ///
-    /// Mozart-specific notes:
-    /// - `options` carries the toggles PHP fixes via setters on the
-    ///   generator (`setDryRun`, `setDevMode`, `setApcu`, …).
-    /// - `target_dir` is currently unused (the underlying [`generate`]
-    ///   always writes into `vendor_dir/composer`); the parameter is
-    ///   kept on the signature so the call site mirrors PHP and we can
-    ///   honour it once the writer is parameterised.
-    /// - `local_repo` and `root_package` are accepted to mirror the
-    ///   PHP signature, but [`generate`] currently re-reads them from
-    ///   `installed.json` / `composer.json`. Refactoring to consume the
-    ///   passed-in values lives in a follow-up.
-    #[allow(clippy::too_many_arguments)]
-    fn dump(
-        &self,
-        options: &AutoloadDumpOptions,
-        config: &Config,
-        local_repo: &LocalRepository,
-        root_package: &RawPackageData,
-        installation_manager: &InstallationManager,
-        target_dir: &str,
-        scan_psr_packages: bool,
-        suffix: Option<&str>,
-        locker: &Locker,
-        strict_ambiguous: bool,
-    ) -> anyhow::Result<ClassMap>;
-}
-
-impl AutoloadGeneratorExt for AutoloadGenerator {
-    fn dump(
-        &self,
-        options: &AutoloadDumpOptions,
-        config: &Config,
-        _local_repo: &LocalRepository,
-        _root_package: &RawPackageData,
-        installation_manager: &InstallationManager,
-        _target_dir: &str,
-        scan_psr_packages: bool,
-        suffix: Option<&str>,
-        locker: &Locker,
-        strict_ambiguous: bool,
-    ) -> anyhow::Result<ClassMap> {
-        // Mirrors PHP: classmap-authoritative implies PSR scanning so
-        // every class gets a fixed map entry.
-        let scan = scan_psr_packages || options.class_map_authoritative;
-
-        // Mirrors PHP's `if (null === $this->devMode)` branch: read the
-        // `dev` flag from `vendor/composer/installed.json` when no
-        // explicit dev-mode has been set on the options.
-        let dev_mode = match options.dev_mode {
-            Some(m) => m,
-            None => read_installed_dev_flag(installation_manager.vendor_dir()),
-        };
-
-        // Mirrors PHP's suffix resolution chain in `dump()`:
-        // 1. explicit argument
-        // 2. `Config::get('autoloader-suffix')`
-        // 3. existing `vendor/autoload.php`'s `ComposerAutoloaderInit{X}`
-        // 4. `composer.lock`'s `content-hash` (when locked)
-        // 5. random hex
-        let resolved_suffix = resolve_suffix(suffix, config, installation_manager, locker)?;
-
-        // Mirrors PHP: `$basePath = realpath(getcwd())`. We don't have
-        // an explicit project_dir on the generator, but `vendor_dir`'s
-        // parent matches the project root for the common
-        // `vendor-dir = "vendor"` layout. When the user points
-        // `vendor-dir` outside the project we fall back to `.`.
-        let project_dir = installation_manager
-            .vendor_dir()
-            .parent()
-            .map(|p| p.to_path_buf())
-            .unwrap_or_else(|| PathBuf::from("."));
-
-        // Mirrors PHP's `$checkPlatform = $config->get('platform-check') !==
-        // false && !($filter instanceof IgnoreAllPlatformRequirementFilter)`.
-        let platform_check = if matches!(
-            options.platform_requirement_filter,
-            PlatformRequirementFilter::IgnoreAll
-        ) {
-            PlatformCheckMode::Disabled
-        } else {
-            platform_check_mode_from_config(&config.platform_check)
-        };
-
-        let cfg = AutoloadConfig {
-            project_dir,
-            vendor_dir: installation_manager.vendor_dir().to_path_buf(),
-            dev_mode,
-            suffix: resolved_suffix,
-            classmap_authoritative: options.class_map_authoritative,
-            optimize: scan,
-            apcu: options.apcu,
-            apcu_prefix: options.apcu_prefix.clone(),
-            // `dump()` does not surface a `--strict-psr` option (that's
-            // a separate command-line flag on `dump-autoload`); the
-            // generator only reports violations via `ClassMap`.
-            strict_psr: false,
-            strict_ambiguous,
-            platform_check,
-            ignore_platform_reqs: matches!(
-                options.platform_requirement_filter,
-                PlatformRequirementFilter::IgnoreAll
-            ),
-        };
-
-        if options.dry_run {
-            // PHP's dry-run still scans and returns the classmap but
-            // skips file writes. The current [`generate`] does not
-            // expose a dry-run hook, so we return an empty ClassMap
-            // for now and surface the limitation here rather than
-            // silently writing files.
-            return Ok(ClassMap {
-                map: BTreeMap::new(),
-                psr_violations: Vec::new(),
-                ambiguous_classes: BTreeMap::new(),
-            });
-        }
-
-        let result = generate(&cfg)?;
-
-        // Mozart's `GenerateResult` only carries summary flags
-        // (`class_count`, `has_psr_violations`, `has_ambiguous_classes`),
-        // not the actual class-name / path entries that PHP's `ClassMap`
-        // exposes. We project the summary onto a `ClassMap` shape so
-        // command code that only branches on `count()` / `has_*()` works
-        // today; refactoring `generate` to surface the full map is
-        // tracked as follow-up work.
-        let mut map = BTreeMap::new();
-        for i in 0..result.class_count {
-            map.insert(format!("__mozart_placeholder_{i}"), String::new());
-        }
-        let psr_violations = if result.has_psr_violations {
-            vec![String::from(
-                "PSR-0/4 violation detected (details not yet surfaced)",
-            )]
-        } else {
-            Vec::new()
-        };
-        let mut ambiguous_classes = BTreeMap::new();
-        if result.has_ambiguous_classes {
-            ambiguous_classes.insert("__mozart_placeholder".to_string(), Vec::new());
-        }
-
-        Ok(ClassMap {
-            map,
-            psr_violations,
-            ambiguous_classes,
-        })
-    }
-}
-
-fn read_installed_dev_flag(vendor_dir: &std::path::Path) -> bool {
-    let path = vendor_dir.join("composer/installed.json");
-    if !path.exists() {
-        return false;
-    }
-    let Ok(content) = std::fs::read_to_string(&path) else {
-        return false;
-    };
-    let Ok(value) = serde_json::from_str::<serde_json::Value>(&content) else {
-        return false;
-    };
-    value.get("dev").and_then(|v| v.as_bool()).unwrap_or(false)
-}
-
-fn resolve_suffix(
-    explicit: Option<&str>,
-    config: &Config,
-    installation_manager: &InstallationManager,
-    locker: &Locker,
-) -> anyhow::Result<String> {
-    if let Some(s) = explicit
-        && !s.is_empty()
-    {
-        return Ok(s.to_string());
-    }
-    if let Some(s) = config.autoloader_suffix.as_ref()
-        && !s.is_empty()
-    {
-        return Ok(s.clone());
-    }
-    let vendor_path = installation_manager.vendor_dir();
-    let autoload_path = vendor_path.join("autoload.php");
-    if autoload_path.exists()
-        && let Ok(content) = std::fs::read_to_string(&autoload_path)
-        && let Some(start) = content.find("ComposerAutoloaderInit")
-    {
-        let rest = &content[start + "ComposerAutoloaderInit".len()..];
-        if let Some(end) = rest.find("::") {
-            let candidate = &rest[..end];
-            if !candidate.is_empty() && candidate.chars().all(|c| c.is_ascii_hexdigit()) {
-                return Ok(candidate.to_string());
-            }
-        }
-    }
-    if locker.is_locked()
-        && let Some(data) = locker.lock_data()?
-        && !data.content_hash.is_empty()
-    {
-        return Ok(data.content_hash);
-    }
-    // Fall back to MD5 of the current timestamp (mirrors PHP's
-    // `bin2hex(random_bytes(16))` — both produce a 32-char hex token
-    // that participates only in classloader naming).
-    let ts = format!("{:?}", std::time::SystemTime::now());
-    Ok(format!("{:x}", md5::compute(ts.as_bytes())))
-}
-
-fn platform_check_mode_from_config(platform_check: &serde_json::Value) -> PlatformCheckMode {
-    match platform_check {
-        serde_json::Value::Bool(false) => PlatformCheckMode::Disabled,
-        serde_json::Value::Bool(true) => PlatformCheckMode::Full,
-        serde_json::Value::String(s) if s == "php-only" => PlatformCheckMode::PhpOnly,
-        // Anything else (including JSON null / unknown strings) falls
-        // through to `Full` — the safe default that PHP also picks
-        // when the value is truthy-but-not-`"php-only"`.
-        _ => PlatformCheckMode::Full,
-    }
-}
diff --git a/crates/mozart-autoload/src/lib.rs b/crates/mozart-autoload/src/lib.rs
deleted file mode 100644
index 0ee48fe..0000000
--- a/crates/mozart-autoload/src/lib.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub mod autoload;
-pub mod dump;
-
-pub use dump::{AutoloadGeneratorExt, ClassMap};
diff --git a/crates/mozart-core/Cargo.toml b/crates/mozart-core/Cargo.toml
index 716a2d5..cca9499 100644
--- a/crates/mozart-core/Cargo.toml
+++ b/crates/mozart-core/Cargo.toml
@@ -4,17 +4,33 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
+mozart-class-map-generator.workspace = true
 mozart-console-macros.workspace = true
+mozart-metadata-minifier.workspace = true
+mozart-php-serialize.workspace = true
+mozart-semver.workspace = true
 mozart-spdx-licenses.workspace = true
 anyhow.workspace = true
+async-trait.workspace = true
+base64.workspace = true
+bzip2.workspace = true
 colored.workspace = true
 dialoguer.workspace = true
+filetime.workspace = true
+flate2.workspace = true
 indexmap.workspace = true
+md5.workspace = true
 regex.workspace = true
 reqwest.workspace = true
 serde.workspace = true
 serde_json.workspace = true
+sha1.workspace = true
+tar.workspace = true
+tempfile.workspace = true
+tokio.workspace = true
 tracing.workspace = true
+url.workspace = true
+zip.workspace = true
 
 [dev-dependencies]
 tempfile.workspace = true
diff --git a/crates/mozart-autoload/src/autoload.rs b/crates/mozart-core/src/autoload.rs
index 21a1de2..0d15900 100644
--- a/crates/mozart-autoload/src/autoload.rs
+++ b/crates/mozart-core/src/autoload.rs
@@ -1,7 +1,13 @@
+use crate::composer::{
+    AutoloadDumpOptions, AutoloadGenerator, InstallationManager, LocalRepository, Locker,
+    PlatformRequirementFilter,
+};
+use crate::config::Config;
+use crate::package::RawPackageData;
+use crate::repository::installed::InstalledPackages;
+use crate::repository::lockfile::LockedPackage;
 use indexmap::IndexSet;
 use mozart_class_map_generator::{scan_classmap_dirs, scan_psr_for_classmap};
-use mozart_registry::installed::InstalledPackages;
-use mozart_registry::lockfile::LockedPackage;
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
@@ -75,6 +81,315 @@ pub struct AutoloadData {
     pub files: BTreeMap<String, String>,
 }
 
+/// Mirror of `Composer\ClassMapGenerator\ClassMap` — the return value
+/// of `AutoloadGenerator::dump`. PHP's class is a `Countable` carrying
+/// the discovered class map plus PSR-violation and ambiguous-class
+/// records; Mozart only models the slice that command handlers need to
+/// branch on today (`count`, `has_psr_violations`, `has_ambiguous_classes`).
+///
+/// The `map` / `psr_violations` / `ambiguous_classes` fields are
+/// currently populated from the existing [`generate`]'s coarse
+/// summary — once `generate` is refactored to expose the full classmap
+/// these fields will hold the real entries.
+pub struct ClassMap {
+    map: BTreeMap<String, String>,
+    psr_violations: Vec<String>,
+    ambiguous_classes: BTreeMap<String, Vec<String>>,
+}
+
+impl ClassMap {
+    /// Mirror of `ClassMap::count`.
+    pub fn count(&self) -> usize {
+        self.map.len()
+    }
+
+    /// Mirror of `count($classMap->getPsrViolations()) > 0`. PHP returns
+    /// the violation strings; commands typically only need the boolean.
+    pub fn has_psr_violations(&self) -> bool {
+        !self.psr_violations.is_empty()
+    }
+
+    /// Mirror of `count($classMap->getAmbiguousClasses($filter)) > 0`.
+    /// `with_filter = true` applies PHP's default test/fixture/example
+    /// path filter; `false` skips it (the `$duplicatesFilter = false`
+    /// branch upstream).
+    pub fn has_ambiguous_classes(&self, with_filter: bool) -> bool {
+        if !with_filter {
+            return !self.ambiguous_classes.is_empty();
+        }
+        let pattern = regex_filter_default();
+        self.ambiguous_classes.values().any(|paths| {
+            paths
+                .iter()
+                .any(|p| !pattern.is_match(&p.replace('\\', "/")))
+        })
+    }
+
+    /// Read access to the underlying map (`getMap()` upstream).
+    pub fn map(&self) -> &BTreeMap<String, String> {
+        &self.map
+    }
+
+    /// Read access to the PSR-violation warnings.
+    pub fn psr_violations(&self) -> &[String] {
+        &self.psr_violations
+    }
+
+    /// Read access to the ambiguous-class records.
+    pub fn ambiguous_classes(&self) -> &BTreeMap<String, Vec<String>> {
+        &self.ambiguous_classes
+    }
+}
+
+fn regex_filter_default() -> regex::Regex {
+    use std::sync::OnceLock;
+    static RE: OnceLock<regex::Regex> = OnceLock::new();
+    RE.get_or_init(|| {
+        // `{/(test|fixture|example|stub)s?/}i` from PHP's
+        // ClassMap::getAmbiguousClasses default.
+        regex::Regex::new(r"(?i)/(test|fixture|example|stub)s?/")
+            .expect("default ambiguous filter compiles")
+    })
+    .clone()
+}
+
+/// Extension trait hanging `dump()` off
+/// [`crate::composer::AutoloadGenerator`]. Mirrors
+/// `Composer\Autoload\AutoloadGenerator::dump()`.
+///
+/// Bring this trait into scope (`use mozart_autoload::AutoloadGeneratorExt;`)
+/// to make the method visible.
+///
+/// Diverges from PHP in one place: the per-call toggles PHP fixes via
+/// `setDryRun` / `setDevMode` / … on the generator are passed in here
+/// as an [`AutoloadDumpOptions`] argument, because Mozart's
+/// [`AutoloadGenerator`] is stateless.
+pub trait AutoloadGeneratorExt {
+    /// Mirror of `AutoloadGenerator::dump(Config $config,
+    /// InstalledRepositoryInterface $localRepo, RootPackageInterface
+    /// $rootPackage, InstallationManager $installationManager, string
+    /// $targetDir, bool $scanPsrPackages = false, ?string $suffix = null,
+    /// ?Locker $locker = null, bool $strictAmbiguous = false)`.
+    ///
+    /// Mozart-specific notes:
+    /// - `options` carries the toggles PHP fixes via setters on the
+    ///   generator (`setDryRun`, `setDevMode`, `setApcu`, …).
+    /// - `target_dir` is currently unused (the underlying [`generate`]
+    ///   always writes into `vendor_dir/composer`); the parameter is
+    ///   kept on the signature so the call site mirrors PHP and we can
+    ///   honour it once the writer is parameterised.
+    /// - `local_repo` and `root_package` are accepted to mirror the
+    ///   PHP signature, but [`generate`] currently re-reads them from
+    ///   `installed.json` / `composer.json`. Refactoring to consume the
+    ///   passed-in values lives in a follow-up.
+    #[allow(clippy::too_many_arguments)]
+    fn dump(
+        &self,
+        options: &AutoloadDumpOptions,
+        config: &Config,
+        local_repo: &LocalRepository,
+        root_package: &RawPackageData,
+        installation_manager: &InstallationManager,
+        target_dir: &str,
+        scan_psr_packages: bool,
+        suffix: Option<&str>,
+        locker: &Locker,
+        strict_ambiguous: bool,
+    ) -> anyhow::Result<ClassMap>;
+}
+
+impl AutoloadGeneratorExt for AutoloadGenerator {
+    fn dump(
+        &self,
+        options: &AutoloadDumpOptions,
+        config: &Config,
+        _local_repo: &LocalRepository,
+        _root_package: &RawPackageData,
+        installation_manager: &InstallationManager,
+        _target_dir: &str,
+        scan_psr_packages: bool,
+        suffix: Option<&str>,
+        locker: &Locker,
+        strict_ambiguous: bool,
+    ) -> anyhow::Result<ClassMap> {
+        // Mirrors PHP: classmap-authoritative implies PSR scanning so
+        // every class gets a fixed map entry.
+        let scan = scan_psr_packages || options.class_map_authoritative;
+
+        // Mirrors PHP's `if (null === $this->devMode)` branch: read the
+        // `dev` flag from `vendor/composer/installed.json` when no
+        // explicit dev-mode has been set on the options.
+        let dev_mode = match options.dev_mode {
+            Some(m) => m,
+            None => read_installed_dev_flag(installation_manager.vendor_dir()),
+        };
+
+        // Mirrors PHP's suffix resolution chain in `dump()`:
+        // 1. explicit argument
+        // 2. `Config::get('autoloader-suffix')`
+        // 3. existing `vendor/autoload.php`'s `ComposerAutoloaderInit{X}`
+        // 4. `composer.lock`'s `content-hash` (when locked)
+        // 5. random hex
+        let resolved_suffix = resolve_suffix(suffix, config, installation_manager, locker)?;
+
+        // Mirrors PHP: `$basePath = realpath(getcwd())`. We don't have
+        // an explicit project_dir on the generator, but `vendor_dir`'s
+        // parent matches the project root for the common
+        // `vendor-dir = "vendor"` layout. When the user points
+        // `vendor-dir` outside the project we fall back to `.`.
+        let project_dir = installation_manager
+            .vendor_dir()
+            .parent()
+            .map(|p| p.to_path_buf())
+            .unwrap_or_else(|| PathBuf::from("."));
+
+        // Mirrors PHP's `$checkPlatform = $config->get('platform-check') !==
+        // false && !($filter instanceof IgnoreAllPlatformRequirementFilter)`.
+        let platform_check = if matches!(
+            options.platform_requirement_filter,
+            PlatformRequirementFilter::IgnoreAll
+        ) {
+            PlatformCheckMode::Disabled
+        } else {
+            platform_check_mode_from_config(&config.platform_check)
+        };
+
+        let cfg = AutoloadConfig {
+            project_dir,
+            vendor_dir: installation_manager.vendor_dir().to_path_buf(),
+            dev_mode,
+            suffix: resolved_suffix,
+            classmap_authoritative: options.class_map_authoritative,
+            optimize: scan,
+            apcu: options.apcu,
+            apcu_prefix: options.apcu_prefix.clone(),
+            // `dump()` does not surface a `--strict-psr` option (that's
+            // a separate command-line flag on `dump-autoload`); the
+            // generator only reports violations via `ClassMap`.
+            strict_psr: false,
+            strict_ambiguous,
+            platform_check,
+            ignore_platform_reqs: matches!(
+                options.platform_requirement_filter,
+                PlatformRequirementFilter::IgnoreAll
+            ),
+        };
+
+        if options.dry_run {
+            // PHP's dry-run still scans and returns the classmap but
+            // skips file writes. The current [`generate`] does not
+            // expose a dry-run hook, so we return an empty ClassMap
+            // for now and surface the limitation here rather than
+            // silently writing files.
+            return Ok(ClassMap {
+                map: BTreeMap::new(),
+                psr_violations: Vec::new(),
+                ambiguous_classes: BTreeMap::new(),
+            });
+        }
+
+        let result = generate(&cfg)?;
+
+        // Mozart's `GenerateResult` only carries summary flags
+        // (`class_count`, `has_psr_violations`, `has_ambiguous_classes`),
+        // not the actual class-name / path entries that PHP's `ClassMap`
+        // exposes. We project the summary onto a `ClassMap` shape so
+        // command code that only branches on `count()` / `has_*()` works
+        // today; refactoring `generate` to surface the full map is
+        // tracked as follow-up work.
+        let mut map = BTreeMap::new();
+        for i in 0..result.class_count {
+            map.insert(format!("__mozart_placeholder_{i}"), String::new());
+        }
+        let psr_violations = if result.has_psr_violations {
+            vec![String::from(
+                "PSR-0/4 violation detected (details not yet surfaced)",
+            )]
+        } else {
+            Vec::new()
+        };
+        let mut ambiguous_classes = BTreeMap::new();
+        if result.has_ambiguous_classes {
+            ambiguous_classes.insert("__mozart_placeholder".to_string(), Vec::new());
+        }
+
+        Ok(ClassMap {
+            map,
+            psr_violations,
+            ambiguous_classes,
+        })
+    }
+}
+
+fn read_installed_dev_flag(vendor_dir: &std::path::Path) -> bool {
+    let path = vendor_dir.join("composer/installed.json");
+    if !path.exists() {
+        return false;
+    }
+    let Ok(content) = std::fs::read_to_string(&path) else {
+        return false;
+    };
+    let Ok(value) = serde_json::from_str::<serde_json::Value>(&content) else {
+        return false;
+    };
+    value.get("dev").and_then(|v| v.as_bool()).unwrap_or(false)
+}
+
+fn resolve_suffix(
+    explicit: Option<&str>,
+    config: &Config,
+    installation_manager: &InstallationManager,
+    locker: &Locker,
+) -> anyhow::Result<String> {
+    if let Some(s) = explicit
+        && !s.is_empty()
+    {
+        return Ok(s.to_string());
+    }
+    if let Some(s) = config.autoloader_suffix.as_ref()
+        && !s.is_empty()
+    {
+        return Ok(s.clone());
+    }
+    let vendor_path = installation_manager.vendor_dir();
+    let autoload_path = vendor_path.join("autoload.php");
+    if autoload_path.exists()
+        && let Ok(content) = std::fs::read_to_string(&autoload_path)
+        && let Some(start) = content.find("ComposerAutoloaderInit")
+    {
+        let rest = &content[start + "ComposerAutoloaderInit".len()..];
+        if let Some(end) = rest.find("::") {
+            let candidate = &rest[..end];
+            if !candidate.is_empty() && candidate.chars().all(|c| c.is_ascii_hexdigit()) {
+                return Ok(candidate.to_string());
+            }
+        }
+    }
+    if locker.is_locked()
+        && let Some(data) = locker.lock_data()?
+        && !data.content_hash.is_empty()
+    {
+        return Ok(data.content_hash);
+    }
+    // Fall back to MD5 of the current timestamp (mirrors PHP's
+    // `bin2hex(random_bytes(16))` — both produce a 32-char hex token
+    // that participates only in classloader naming).
+    let ts = format!("{:?}", std::time::SystemTime::now());
+    Ok(format!("{:x}", md5::compute(ts.as_bytes())))
+}
+
+fn platform_check_mode_from_config(platform_check: &serde_json::Value) -> PlatformCheckMode {
+    match platform_check {
+        serde_json::Value::Bool(false) => PlatformCheckMode::Disabled,
+        serde_json::Value::Bool(true) => PlatformCheckMode::Full,
+        serde_json::Value::String(s) if s == "php-only" => PlatformCheckMode::PhpOnly,
+        // Anything else (including JSON null / unknown strings) falls
+        // through to `Full` — the safe default that PHP also picks
+        // when the value is truthy-but-not-`"php-only"`.
+        _ => PlatformCheckMode::Full,
+    }
+}
+
 /// Escape a string for use in a PHP single-quoted string literal.
 pub fn php_escape(s: &str) -> String {
     s.replace('\\', "\\\\").replace('\'', "\\'")
@@ -758,7 +1073,7 @@ pub fn determine_suffix(working_dir: &Path, vendor_dir: &Path) -> anyhow::Result
     // Try composer.lock content-hash
     let lock_path = working_dir.join("composer.lock");
     if lock_path.exists() {
-        let lock = mozart_registry::lockfile::LockFile::read_from_file(&lock_path)?;
+        let lock = crate::repository::lockfile::LockFile::read_from_file(&lock_path)?;
         return Ok(lock.content_hash);
     }
 
@@ -957,7 +1272,7 @@ pub fn generate(config: &AutoloadConfig) -> anyhow::Result<GenerateResult> {
         installed
             .packages
             .iter()
-            .map(|p| mozart_registry::lockfile::LockedPackage {
+            .map(|p| crate::repository::lockfile::LockedPackage {
                 name: p.name.clone(),
                 version: p.version.clone(),
                 version_normalized: p.version_normalized.clone(),
@@ -1054,7 +1369,7 @@ pub fn generate(config: &AutoloadConfig) -> anyhow::Result<GenerateResult> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use mozart_registry::installed::{InstalledPackageEntry, InstalledPackages};
+    use crate::repository::installed::{InstalledPackageEntry, InstalledPackages};
     use std::collections::BTreeMap;
     use tempfile::tempdir;
 
diff --git a/crates/mozart-sat-resolver/src/lib.rs b/crates/mozart-core/src/dependency_resolver.rs
index 2e3fefb..2e3fefb 100644
--- a/crates/mozart-sat-resolver/src/lib.rs
+++ b/crates/mozart-core/src/dependency_resolver.rs
diff --git a/crates/mozart-sat-resolver/src/decisions.rs b/crates/mozart-core/src/dependency_resolver/decisions.rs
index e9cc935..510092f 100644
--- a/crates/mozart-sat-resolver/src/decisions.rs
+++ b/crates/mozart-core/src/dependency_resolver/decisions.rs
@@ -1,6 +1,6 @@
-use crate::error::SolverBugError;
-use crate::pool::{Literal, PackageId, literal_to_package_id};
-use crate::rule_set::RuleId;
+use super::error::SolverBugError;
+use super::pool::{Literal, PackageId, literal_to_package_id};
+use super::rule_set::RuleId;
 use indexmap::IndexMap;
 
 /// A decision entry: which literal was decided and which rule caused it.
diff --git a/crates/mozart-sat-resolver/src/error.rs b/crates/mozart-core/src/dependency_resolver/error.rs
index e4b9841..e4b9841 100644
--- a/crates/mozart-sat-resolver/src/error.rs
+++ b/crates/mozart-core/src/dependency_resolver/error.rs
diff --git a/crates/mozart-sat-resolver/src/policy.rs b/crates/mozart-core/src/dependency_resolver/policy.rs
index f45c4f5..d761d58 100644
--- a/crates/mozart-sat-resolver/src/policy.rs
+++ b/crates/mozart-core/src/dependency_resolver/policy.rs
@@ -1,4 +1,4 @@
-use crate::pool::{Literal, Pool};
+use super::pool::{Literal, Pool};
 use indexmap::IndexMap;
 
 /// Version selection policy: decides which version to prefer when multiple
@@ -214,7 +214,7 @@ fn stability_priority(version: &str) -> u8 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::pool::PoolPackageInput;
+    use crate::dependency_resolver::pool::PoolPackageInput;
 
     fn make_input(name: &str, version: &str) -> PoolPackageInput {
         PoolPackageInput {
diff --git a/crates/mozart-sat-resolver/src/pool.rs b/crates/mozart-core/src/dependency_resolver/pool.rs
index 8a63c05..8a63c05 100644
--- a/crates/mozart-sat-resolver/src/pool.rs
+++ b/crates/mozart-core/src/dependency_resolver/pool.rs
diff --git a/crates/mozart-sat-resolver/src/pool_builder.rs b/crates/mozart-core/src/dependency_resolver/pool_builder.rs
index 6088e7d..e037b01 100644
--- a/crates/mozart-sat-resolver/src/pool_builder.rs
+++ b/crates/mozart-core/src/dependency_resolver/pool_builder.rs
@@ -1,4 +1,4 @@
-use crate::pool::{Pool, PoolLink, PoolPackageInput};
+use super::pool::{Pool, PoolLink, PoolPackageInput};
 use indexmap::IndexSet;
 use std::collections::VecDeque;
 
@@ -49,11 +49,11 @@ impl PoolBuilder {
         if self
             .ignore_platform_reqs
             .iter()
-            .any(|p| mozart_core::matches_wildcard(name, p))
+            .any(|p| crate::matches_wildcard(name, p))
         {
             return true;
         }
-        self.ignore_all_platform_reqs && mozart_core::platform::is_platform_package(name)
+        self.ignore_all_platform_reqs && crate::platform::is_platform_package(name)
     }
 
     /// Add a package version to the builder. Returns true if it's new.
diff --git a/crates/mozart-sat-resolver/src/problem.rs b/crates/mozart-core/src/dependency_resolver/problem.rs
index a1692fd..e9a1464 100644
--- a/crates/mozart-sat-resolver/src/problem.rs
+++ b/crates/mozart-core/src/dependency_resolver/problem.rs
@@ -1,6 +1,6 @@
-use crate::pool::{Literal, Pool, literal_to_package_id};
-use crate::rule::{ReasonData, Rule, RuleReason};
-use crate::rule_set::{RuleId, RuleSet};
+use super::pool::{Literal, Pool, literal_to_package_id};
+use super::rule::{ReasonData, Rule, RuleReason};
+use super::rule_set::{RuleId, RuleSet};
 
 /// Represents a conflict found during resolution.
 /// Collects the rules involved in the problem.
@@ -402,8 +402,8 @@ fn format_providers_abs(pool: &Pool, literals: &[Literal]) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::pool::PoolPackageInput;
-    use crate::rule::{ReasonData, Rule, RuleReason, RuleType};
+    use crate::dependency_resolver::pool::PoolPackageInput;
+    use crate::dependency_resolver::rule::{ReasonData, Rule, RuleReason, RuleType};
 
     fn make_input(name: &str, version: &str, pretty: &str) -> PoolPackageInput {
         PoolPackageInput {
@@ -481,7 +481,7 @@ mod tests {
         let rule = Rule::new(
             vec![-1, 2],
             RuleReason::PackageRequires,
-            ReasonData::Link(crate::pool::PoolLink {
+            ReasonData::Link(super::super::pool::PoolLink {
                 source: "foo/bar".to_string(),
                 target: "baz/qux".to_string(),
                 constraint: "^2.0".to_string(),
diff --git a/crates/mozart-sat-resolver/src/request.rs b/crates/mozart-core/src/dependency_resolver/request.rs
index 26c17ba..4d650b0 100644
--- a/crates/mozart-sat-resolver/src/request.rs
+++ b/crates/mozart-core/src/dependency_resolver/request.rs
@@ -1,4 +1,4 @@
-use crate::pool::PackageId;
+use super::pool::PackageId;
 use indexmap::IndexMap;
 
 /// A requirement: package name + version constraint string.
diff --git a/crates/mozart-sat-resolver/src/rule.rs b/crates/mozart-core/src/dependency_resolver/rule.rs
index 860ae79..546b932 100644
--- a/crates/mozart-sat-resolver/src/rule.rs
+++ b/crates/mozart-core/src/dependency_resolver/rule.rs
@@ -1,4 +1,4 @@
-use crate::pool::{Literal, PoolLink};
+use super::pool::{Literal, PoolLink};
 use std::fmt;
 
 /// Why a rule was created.
diff --git a/crates/mozart-sat-resolver/src/rule_set.rs b/crates/mozart-core/src/dependency_resolver/rule_set.rs
index 918bdae..3636a0f 100644
--- a/crates/mozart-sat-resolver/src/rule_set.rs
+++ b/crates/mozart-core/src/dependency_resolver/rule_set.rs
@@ -1,4 +1,4 @@
-use crate::rule::{Rule, RuleType};
+use super::rule::{Rule, RuleType};
 use indexmap::IndexMap;
 
 /// A unique identifier for a rule within the RuleSet.
@@ -151,7 +151,7 @@ impl<'a> Iterator for RuleTypeIterator<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::rule::{ReasonData, RuleReason};
+    use crate::dependency_resolver::rule::{ReasonData, RuleReason};
 
     #[test]
     fn test_add_and_lookup() {
diff --git a/crates/mozart-sat-resolver/src/rule_set_generator.rs b/crates/mozart-core/src/dependency_resolver/rule_set_generator.rs
index 2ab9f86..bd06419 100644
--- a/crates/mozart-sat-resolver/src/rule_set_generator.rs
+++ b/crates/mozart-core/src/dependency_resolver/rule_set_generator.rs
@@ -1,6 +1,6 @@
-use crate::pool::{Literal, PackageId, Pool, PoolLink};
-use crate::rule::{ReasonData, Rule, RuleReason, RuleType};
-use crate::rule_set::RuleSet;
+use super::pool::{Literal, PackageId, Pool, PoolLink};
+use super::rule::{ReasonData, Rule, RuleReason, RuleType};
+use super::rule_set::RuleSet;
 use indexmap::IndexMap;
 use indexmap::IndexSet;
 use mozart_semver::VersionConstraint;
@@ -49,11 +49,11 @@ impl<'a> RuleSetGenerator<'a> {
         if self
             .ignore_platform_reqs
             .iter()
-            .any(|p| mozart_core::matches_wildcard(name, p))
+            .any(|p| crate::matches_wildcard(name, p))
         {
             return true;
         }
-        self.ignore_all_platform_reqs && mozart_core::platform::is_platform_package(name)
+        self.ignore_all_platform_reqs && crate::platform::is_platform_package(name)
     }
 
     /// Generate rules for a set of requirements and fixed packages.
@@ -373,7 +373,7 @@ fn root_self_fulfills(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::pool::{Pool, PoolLink, PoolPackageInput};
+    use crate::dependency_resolver::pool::{Pool, PoolLink, PoolPackageInput};
 
     fn make_input(name: &str, version: &str) -> PoolPackageInput {
         PoolPackageInput {
diff --git a/crates/mozart-sat-resolver/src/rule_watch_graph.rs b/crates/mozart-core/src/dependency_resolver/rule_watch_graph.rs
index 202dcca..ac9e5b2 100644
--- a/crates/mozart-sat-resolver/src/rule_watch_graph.rs
+++ b/crates/mozart-core/src/dependency_resolver/rule_watch_graph.rs
@@ -1,7 +1,7 @@
-use crate::decisions::Decisions;
-use crate::pool::Literal;
-use crate::rule::Rule;
-use crate::rule_set::RuleId;
+use super::decisions::Decisions;
+use super::pool::Literal;
+use super::rule::Rule;
+use super::rule_set::RuleId;
 use indexmap::IndexMap;
 
 /// A watch node: tracks which 2 literals a rule watches.
@@ -109,8 +109,8 @@ impl RuleWatchGraph {
         decided_literal: Literal,
         level: i32,
         decisions: &mut Decisions,
-        rules: &crate::rule_set::RuleSet,
-    ) -> Result<Option<RuleId>, crate::error::SolverBugError> {
+        rules: &super::rule_set::RuleSet,
+    ) -> Result<Option<RuleId>, super::error::SolverBugError> {
         // We look for rules watching the negation of the decided literal
         let literal = -decided_literal;
 
@@ -223,8 +223,8 @@ impl Default for RuleWatchGraph {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::rule::{ReasonData, Rule, RuleReason};
-    use crate::rule_set::RuleSet;
+    use crate::dependency_resolver::rule::{ReasonData, Rule, RuleReason};
+    use crate::dependency_resolver::rule_set::RuleSet;
 
     #[test]
     fn test_insert_assertion_skipped() {
@@ -251,7 +251,7 @@ mod tests {
         let mut rs = RuleSet::new();
         rs.add(
             Rule::new(vec![1, 2], RuleReason::PackageRequires, ReasonData::None),
-            crate::rule::RuleType::Package,
+            super::super::rule::RuleType::Package,
         );
 
         let mut graph = RuleWatchGraph::new();
@@ -272,7 +272,7 @@ mod tests {
         let mut rs = RuleSet::new();
         rs.add(
             Rule::new(vec![1, 2], RuleReason::PackageRequires, ReasonData::None),
-            crate::rule::RuleType::Package,
+            super::super::rule::RuleType::Package,
         );
 
         let mut graph = RuleWatchGraph::new();
diff --git a/crates/mozart-sat-resolver/src/solver.rs b/crates/mozart-core/src/dependency_resolver/solver.rs
index 8739381..4abb888 100644
--- a/crates/mozart-sat-resolver/src/solver.rs
+++ b/crates/mozart-core/src/dependency_resolver/solver.rs
@@ -1,11 +1,11 @@
-use crate::decisions::Decisions;
-use crate::error::{SolverBugError, SolverError};
-use crate::policy::DefaultPolicy;
-use crate::pool::{Literal, PackageId, Pool, literal_to_package_id};
-use crate::problem::Problem;
-use crate::rule::{ReasonData, Rule, RuleReason, RuleType};
-use crate::rule_set::{RuleId, RuleSet};
-use crate::rule_watch_graph::RuleWatchGraph;
+use super::decisions::Decisions;
+use super::error::{SolverBugError, SolverError};
+use super::policy::DefaultPolicy;
+use super::pool::{Literal, PackageId, Pool, literal_to_package_id};
+use super::problem::Problem;
+use super::rule::{ReasonData, Rule, RuleReason, RuleType};
+use super::rule_set::{RuleId, RuleSet};
+use super::rule_watch_graph::RuleWatchGraph;
 use indexmap::{IndexMap, IndexSet};
 
 /// Result of solving: the list of package IDs to install.
@@ -814,8 +814,8 @@ impl<'a> Solver<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::pool::PoolPackageInput;
-    use crate::rule::{ReasonData, Rule, RuleReason, RuleType};
+    use crate::dependency_resolver::pool::PoolPackageInput;
+    use crate::dependency_resolver::rule::{ReasonData, Rule, RuleReason, RuleType};
 
     fn make_input(name: &str, version: &str) -> PoolPackageInput {
         PoolPackageInput {
diff --git a/crates/mozart-sat-resolver/src/transaction.rs b/crates/mozart-core/src/dependency_resolver/transaction.rs
index bf7befc..736d230 100644
--- a/crates/mozart-sat-resolver/src/transaction.rs
+++ b/crates/mozart-core/src/dependency_resolver/transaction.rs
@@ -1,5 +1,5 @@
-use crate::decisions::Decisions;
-use crate::pool::{PackageId, Pool, literal_to_package_id};
+use super::decisions::Decisions;
+use super::pool::{PackageId, Pool, literal_to_package_id};
 use indexmap::{IndexMap, IndexSet};
 
 /// An operation to perform on a package.
@@ -367,7 +367,7 @@ impl<'a> LockTransaction<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::pool::{PoolLink, PoolPackageInput};
+    use crate::dependency_resolver::pool::{PoolLink, PoolPackageInput};
 
     fn make_input(name: &str, version: &str, pretty: &str) -> PoolPackageInput {
         PoolPackageInput {
diff --git a/crates/mozart-core/src/lib.rs b/crates/mozart-core/src/lib.rs
index f37bf43..72f5ae1 100644
--- a/crates/mozart-core/src/lib.rs
+++ b/crates/mozart-core/src/lib.rs
@@ -1,11 +1,13 @@
 extern crate self as mozart_core;
 
 pub mod advisory;
+pub mod autoload;
 pub mod composer;
 pub mod config;
 pub mod config_source;
 pub mod config_validator;
 pub mod console;
+pub mod dependency_resolver;
 pub mod exit_code;
 pub mod factory;
 pub mod http;
@@ -14,10 +16,12 @@ pub mod package;
 pub mod package_info;
 pub mod package_sorter;
 pub mod platform;
+pub mod repository;
 pub mod repository_utils;
 pub mod script_events;
 pub mod suggest;
 pub mod validation;
+pub mod vcs;
 pub mod version_bumper;
 pub mod wildcard;
 
diff --git a/crates/mozart-core/src/package.rs b/crates/mozart-core/src/package.rs
index a850517..64974fd 100644
--- a/crates/mozart-core/src/package.rs
+++ b/crates/mozart-core/src/package.rs
@@ -5,6 +5,8 @@ use std::fmt;
 use std::fs;
 use std::path::Path;
 
+pub mod archiver;
+
 /// Package stability level.
 /// Higher value = less stable.
 /// Corresponds to `Composer\Package\BasePackage::STABILITY_*`.
diff --git a/crates/mozart-archiver/src/lib.rs b/crates/mozart-core/src/package/archiver.rs
index 30c678a..30c678a 100644
--- a/crates/mozart-archiver/src/lib.rs
+++ b/crates/mozart-core/src/package/archiver.rs
diff --git a/crates/mozart-archiver/src/manager.rs b/crates/mozart-core/src/package/archiver/manager.rs
index bd3cafa..bd5083e 100644
--- a/crates/mozart-archiver/src/manager.rs
+++ b/crates/mozart-core/src/package/archiver/manager.rs
@@ -1,9 +1,8 @@
-use std::path::{Path, PathBuf};
-
-use crate::{
+use super::{
     ArchiveFormat, collect_archivable_files, create_archive, generate_archive_filename,
     parse_composer_excludes, parse_gitattributes, parse_gitignore_pattern, self_exclusion_patterns,
 };
+use std::path::{Path, PathBuf};
 
 /// A package to be archived.
 ///
@@ -171,7 +170,7 @@ impl ArchiveManager {
         target_dir: &Path,
         file_name: Option<&str>,
         ignore_filters: bool,
-        files_cache: &mozart_registry::cache::Cache,
+        files_cache: &crate::repository::cache::Cache,
     ) -> anyhow::Result<PathBuf> {
         let archive_format = ArchiveFormat::parse(format).ok_or_else(|| {
             anyhow::anyhow!(
@@ -229,7 +228,7 @@ impl ArchiveManager {
 /// composer.json.
 async fn acquire_source(
     package: &ArchivePackage,
-    files_cache: &mozart_registry::cache::Cache,
+    files_cache: &crate::repository::cache::Cache,
 ) -> anyhow::Result<AcquiredSource> {
     match package {
         ArchivePackage::Root { source_dir, .. } => {
@@ -263,7 +262,7 @@ async fn acquire_source(
             let temp_dir = temp_base.join(&unique);
             std::fs::create_dir_all(&temp_dir)?;
 
-            let bytes = mozart_registry::downloader::download_dist(
+            let bytes = crate::repository::downloader::download_dist(
                 dist_url,
                 dist_shasum.as_deref(),
                 None,
@@ -272,9 +271,9 @@ async fn acquire_source(
             .await?;
 
             match dist_type.as_str() {
-                "zip" => mozart_registry::downloader::extract_zip(&bytes, &temp_dir)?,
+                "zip" => crate::repository::downloader::extract_zip(&bytes, &temp_dir)?,
                 "tar" | "tar.gz" | "tgz" => {
-                    mozart_registry::downloader::extract_tar_gz(&bytes, &temp_dir)?
+                    crate::repository::downloader::extract_tar_gz(&bytes, &temp_dir)?
                 }
                 other => {
                     let _ = std::fs::remove_dir_all(&temp_dir);
diff --git a/crates/mozart-registry/src/lib.rs b/crates/mozart-core/src/repository.rs
index e35056c..ba96729 100644
--- a/crates/mozart-registry/src/lib.rs
+++ b/crates/mozart-core/src/repository.rs
@@ -10,6 +10,7 @@ pub mod installer_executor;
 pub mod lockfile;
 pub mod packagist;
 pub mod path_repository;
+#[allow(clippy::module_inception)]
 pub mod repository;
 pub mod repository_filter;
 pub mod resolver;
diff --git a/crates/mozart-registry/src/advisory.rs b/crates/mozart-core/src/repository/advisory.rs
index 86d37af..02a6e1a 100644
--- a/crates/mozart-registry/src/advisory.rs
+++ b/crates/mozart-core/src/repository/advisory.rs
@@ -1,12 +1,10 @@
-use std::collections::BTreeMap;
-
+use super::packagist::SecurityAdvisory;
+use super::repository::RepositorySet;
+use crate::advisory::{AbandonedHandling, AuditFormat};
+use crate::console::Console;
+use crate::{console_writeln, console_writeln_error};
 use indexmap::IndexMap;
-use mozart_core::advisory::{AbandonedHandling, AuditFormat};
-use mozart_core::console::Console;
-use mozart_core::{console_writeln, console_writeln_error};
-
-use crate::packagist::SecurityAdvisory;
-use crate::repository::RepositorySet;
+use std::collections::BTreeMap;
 
 /// A package being audited, with version and abandonment information.
 #[derive(Debug, Clone)]
diff --git a/crates/mozart-registry/src/browse_repos.rs b/crates/mozart-core/src/repository/browse_repos.rs
index 0f9b169..d54465f 100644
--- a/crates/mozart-registry/src/browse_repos.rs
+++ b/crates/mozart-core/src/repository/browse_repos.rs
@@ -8,11 +8,11 @@
 //! `CompletePackageInterface` (`getSupport()['source']`,
 //! `getSourceUrl()`, `getHomepage()`).
 
-use crate::cache::Cache;
-use crate::installed::{InstalledPackageEntry, InstalledPackages};
-use crate::lockfile::LockedPackage;
-use crate::packagist::{self, PackagistVersion};
-use mozart_core::package::RawPackageData;
+use super::super::package::RawPackageData;
+use super::cache::Cache;
+use super::installed::{InstalledPackageEntry, InstalledPackages};
+use super::lockfile::LockedPackage;
+use super::packagist::{self, PackagistVersion};
 
 /// Subset of `Composer\Package\CompletePackageInterface` consumed by
 /// `HomeCommand::handlePackage`. Every backing repo flattens its
@@ -185,7 +185,7 @@ mod tests {
             name: name.to_string(),
             version: "1.0.0".to_string(),
             version_normalized: None,
-            source: source_url.map(|url| crate::lockfile::LockedSource {
+            source: source_url.map(|url| super::super::lockfile::LockedSource {
                 source_type: "git".to_string(),
                 url: url.to_string(),
                 reference: None,
diff --git a/crates/mozart-registry/src/cache.rs b/crates/mozart-core/src/repository/cache.rs
index 39e3e8d..39e3e8d 100644
--- a/crates/mozart-registry/src/cache.rs
+++ b/crates/mozart-core/src/repository/cache.rs
diff --git a/crates/mozart-registry/src/composer_repo.rs b/crates/mozart-core/src/repository/composer_repo.rs
index ef091ef..3413ad5 100644
--- a/crates/mozart-registry/src/composer_repo.rs
+++ b/crates/mozart-core/src/repository/composer_repo.rs
@@ -19,10 +19,10 @@
 //! variants are out of scope here — the in-process installer fixtures only
 //! exercise the legacy embedded-packages form.
 
-use crate::packagist::PackagistVersion;
-use crate::repository_filter::RepositoryFilter;
+use super::packagist::PackagistVersion;
+use super::repository_filter::RepositoryFilter;
+use crate::package::RawRepository;
 use indexmap::IndexSet;
-use mozart_core::package::RawRepository;
 use std::path::PathBuf;
 
 /// One package version drawn from a `type: composer` repository.
diff --git a/crates/mozart-registry/src/download_manager.rs b/crates/mozart-core/src/repository/download_manager.rs
index 7c6ff73..d422899 100644
--- a/crates/mozart-registry/src/download_manager.rs
+++ b/crates/mozart-core/src/repository/download_manager.rs
@@ -3,15 +3,15 @@
 
 use std::path::PathBuf;
 
-use mozart_core::composer::{InstallationSource, LocalPackage};
-use mozart_vcs::downloader::VcsDownloader;
-use mozart_vcs::downloader::git::GitDownloader;
-use mozart_vcs::downloader::hg::HgDownloader;
-use mozart_vcs::downloader::svn::SvnDownloader;
-use mozart_vcs::process::ProcessExecutor;
-use mozart_vcs::util::git::GitUtil;
-use mozart_vcs::util::hg::HgUtil;
-use mozart_vcs::util::svn::SvnUtil;
+use crate::composer::{InstallationSource, LocalPackage};
+use crate::vcs::downloader::VcsDownloader;
+use crate::vcs::downloader::git::GitDownloader;
+use crate::vcs::downloader::hg::HgDownloader;
+use crate::vcs::downloader::svn::SvnDownloader;
+use crate::vcs::process::ProcessExecutor;
+use crate::vcs::util::git::GitUtil;
+use crate::vcs::util::hg::HgUtil;
+use crate::vcs::util::svn::SvnUtil;
 
 /// Selects a `VcsDownloader` for a package based on its installation source
 /// and source type. Mirrors `DownloadManager::getDownloaderForPackage`:
@@ -70,7 +70,7 @@ impl DownloadManager {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use mozart_core::composer::PackageReference;
+    use crate::composer::PackageReference;
     use serde_json::Value;
 
     fn pkg(
diff --git a/crates/mozart-registry/src/downloader.rs b/crates/mozart-core/src/repository/downloader.rs
index 3cb991b..b0d2a6a 100644
--- a/crates/mozart-registry/src/downloader.rs
+++ b/crates/mozart-core/src/repository/downloader.rs
@@ -1,4 +1,4 @@
-use crate::cache::Cache;
+use super::cache::Cache;
 use indexmap::IndexSet;
 use sha1::{Digest, Sha1};
 use std::fs;
@@ -109,7 +109,7 @@ pub async fn download_dist(
         }
     }
 
-    let client = mozart_core::http::client_builder().build()?;
+    let client = crate::http::client_builder().build()?;
     let response = client.get(url).send().await?;
     tracing::debug!(status = %response.status(), "received response");
 
diff --git a/crates/mozart-registry/src/inline_package.rs b/crates/mozart-core/src/repository/inline_package.rs
index 95f842f..fd33d19 100644
--- a/crates/mozart-registry/src/inline_package.rs
+++ b/crates/mozart-core/src/repository/inline_package.rs
@@ -5,10 +5,10 @@
 //! These packages need no network fetch — they go straight into the resolver
 //! pool and into the generated lockfile entry verbatim.
 
-use crate::packagist::PackagistVersion;
-use crate::repository_filter::RepositoryFilter;
+use super::packagist::PackagistVersion;
+use super::repository_filter::RepositoryFilter;
+use crate::package::RawRepository;
 use indexmap::IndexSet;
-use mozart_core::package::RawRepository;
 
 /// One package extracted from a `type: package` repository.
 pub struct InlinePackage {
diff --git a/crates/mozart-registry/src/installed.rs b/crates/mozart-core/src/repository/installed.rs
index 108b844..544e948 100644
--- a/crates/mozart-registry/src/installed.rs
+++ b/crates/mozart-core/src/repository/installed.rs
@@ -1,5 +1,5 @@
-use mozart_core::installer::HasSuggests;
-use mozart_core::package::to_json_pretty;
+use crate::installer::HasSuggests;
+use crate::package::to_json_pretty;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::fs;
diff --git a/crates/mozart-registry/src/installer_executor/filesystem.rs b/crates/mozart-core/src/repository/installer_executor/filesystem.rs
index cb1a2cc..347f2a0 100644
--- a/crates/mozart-registry/src/installer_executor/filesystem.rs
+++ b/crates/mozart-core/src/repository/installer_executor/filesystem.rs
@@ -2,15 +2,13 @@
 //!
 //! This is the verb behind `mozart install` / `mozart update` — it pulls
 //! dist archives via [`crate::downloader`], clones VCS sources via
-//! [`mozart_vcs`], and removes vendor directories. Test code substitutes a
+//! [`crate::vcs`], and removes vendor directories. Test code substitutes a
 //! recording-only executor instead (added in a later step).
 
-use std::path::Path;
-
-use crate::cache::Cache;
-use crate::downloader;
-
+use super::super::cache::Cache;
+use super::super::downloader;
 use super::{ExecuteContext, InstallerExecutor, PackageOperation};
+use std::path::Path;
 
 pub struct FilesystemExecutor {
     files_cache: Cache,
@@ -144,26 +142,26 @@ fn install_from_source(
 
     match source_type {
         "git" => {
-            let process = mozart_vcs::process::ProcessExecutor::new();
+            let process = crate::vcs::process::ProcessExecutor::new();
             let git_util =
-                mozart_vcs::util::git::GitUtil::new(process, vendor_dir.join(".cache").join("git"));
-            let downloader = mozart_vcs::downloader::git::GitDownloader::new(git_util);
-            use mozart_vcs::downloader::VcsDownloader;
+                crate::vcs::util::git::GitUtil::new(process, vendor_dir.join(".cache").join("git"));
+            let downloader = crate::vcs::downloader::git::GitDownloader::new(git_util);
+            use crate::vcs::downloader::VcsDownloader;
             downloader.download(url, reference, &target)?;
             downloader.install(url, reference, &target)?;
         }
         "svn" => {
-            let process = mozart_vcs::process::ProcessExecutor::new();
-            let svn_util = mozart_vcs::util::svn::SvnUtil::new(process);
-            let downloader = mozart_vcs::downloader::svn::SvnDownloader::new(svn_util);
-            use mozart_vcs::downloader::VcsDownloader;
+            let process = crate::vcs::process::ProcessExecutor::new();
+            let svn_util = crate::vcs::util::svn::SvnUtil::new(process);
+            let downloader = crate::vcs::downloader::svn::SvnDownloader::new(svn_util);
+            use crate::vcs::downloader::VcsDownloader;
             downloader.install(url, reference, &target)?;
         }
         "hg" => {
-            let process = mozart_vcs::process::ProcessExecutor::new();
-            let hg_util = mozart_vcs::util::hg::HgUtil::new(process);
-            let downloader = mozart_vcs::downloader::hg::HgDownloader::new(hg_util);
-            use mozart_vcs::downloader::VcsDownloader;
+            let process = crate::vcs::process::ProcessExecutor::new();
+            let hg_util = crate::vcs::util::hg::HgUtil::new(process);
+            let downloader = crate::vcs::downloader::hg::HgDownloader::new(hg_util);
+            use crate::vcs::downloader::VcsDownloader;
             downloader.install(url, reference, &target)?;
         }
         _ => {
diff --git a/crates/mozart-registry/src/installer_executor/mod.rs b/crates/mozart-core/src/repository/installer_executor/mod.rs
index 4ddad66..f67c612 100644
--- a/crates/mozart-registry/src/installer_executor/mod.rs
+++ b/crates/mozart-core/src/repository/installer_executor/mod.rs
@@ -15,8 +15,8 @@
 
 use std::path::PathBuf;
 
-use crate::installed::InstalledPackageEntry;
-use crate::lockfile::{LockAlias, LockedPackage};
+use super::installed::InstalledPackageEntry;
+use super::lockfile::{LockAlias, LockedPackage};
 
 pub mod filesystem;
 pub mod trace_recorder;
diff --git a/crates/mozart-registry/src/installer_executor/trace_recorder.rs b/crates/mozart-core/src/repository/installer_executor/trace_recorder.rs
index b60a869..b60a869 100644
--- a/crates/mozart-registry/src/installer_executor/trace_recorder.rs
+++ b/crates/mozart-core/src/repository/installer_executor/trace_recorder.rs
diff --git a/crates/mozart-registry/src/installer_executor/transaction.rs b/crates/mozart-core/src/repository/installer_executor/transaction.rs
index 95f9718..128b3db 100644
--- a/crates/mozart-registry/src/installer_executor/transaction.rs
+++ b/crates/mozart-core/src/repository/installer_executor/transaction.rs
@@ -6,8 +6,8 @@
 //! same operation-computation machinery without going through the `install`
 //! command module.
 
-use crate::installed::{InstalledPackageEntry, InstalledPackages};
-use crate::lockfile::{LockFile, LockedPackage};
+use super::super::installed::{InstalledPackageEntry, InstalledPackages};
+use super::super::lockfile::{LockFile, LockedPackage};
 use indexmap::IndexSet;
 use std::path::Path;
 
@@ -327,7 +327,8 @@ pub fn previously_installed_alias_versions(
                 if !target_str.to_lowercase().ends_with("-dev") {
                     continue;
                 }
-                if let Some(normalized) = crate::resolver::normalize_branch_alias_target(target_str)
+                if let Some(normalized) =
+                    super::super::resolver::normalize_branch_alias_target(target_str)
                 {
                     out.push(normalized);
                     emitted_explicit_alias = true;
diff --git a/crates/mozart-registry/src/lockfile.rs b/crates/mozart-core/src/repository/lockfile.rs
index fd6b5e3..4c41bbb 100644
--- a/crates/mozart-registry/src/lockfile.rs
+++ b/crates/mozart-core/src/repository/lockfile.rs
@@ -1,10 +1,10 @@
-use crate::packagist::{PackagistDist, PackagistSource, PackagistVersion};
-use crate::repository::RepositorySet;
-use crate::resolver::ResolvedPackage;
+use super::packagist::{PackagistDist, PackagistSource, PackagistVersion};
+use super::repository::RepositorySet;
+use super::resolver::ResolvedPackage;
+use crate::installer::HasSuggests;
+use crate::package::{RawPackageData, to_json_pretty};
 use indexmap::IndexMap;
 use indexmap::IndexSet;
-use mozart_core::installer::HasSuggests;
-use mozart_core::package::{RawPackageData, to_json_pretty};
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, VecDeque};
 use std::fs;
@@ -260,7 +260,7 @@ impl LockFile {
     /// Mirrors `Composer\Package\Locker::getMissingRequirementInfo()`.
     pub fn get_missing_requirement_info(
         &self,
-        root: &mozart_core::package::RawPackageData,
+        root: &crate::package::RawPackageData,
         include_dev: bool,
     ) -> Vec<String> {
         let mut messages = Vec::new();
@@ -377,7 +377,7 @@ pub fn locked_package_branch_aliases(pkg: &LockedPackage) -> Vec<LockAlias> {
         if !target_str.to_lowercase().ends_with("-dev") {
             continue;
         }
-        let Some(normalized) = crate::resolver::normalize_branch_alias_target(target_str) else {
+        let Some(normalized) = super::resolver::normalize_branch_alias_target(target_str) else {
             continue;
         };
         // Pretty-form trim: Composer's `Preg::replace('{(\.9{7})+}', '.x', ...)`
@@ -402,7 +402,7 @@ fn check_requirement_set(
     any_missing: &mut bool,
 ) {
     for (name, constraint_str) in requires {
-        if mozart_core::platform::is_platform_package(name) {
+        if crate::platform::is_platform_package(name) {
             continue;
         }
         if constraint_str.trim() == "self.version" {
@@ -495,7 +495,7 @@ impl LockFileGenerationRequest {
     /// the Packagist fetch for resolved packages that came from a `type:
     /// package` repository.
     fn inline_lookup(&self, name: &str, version_normalized: &str) -> Option<PackagistVersion> {
-        crate::inline_package::collect_inline_packages(&self.composer_json.repositories)
+        super::inline_package::collect_inline_packages(&self.composer_json.repositories)
             .into_iter()
             .find(|ipkg| ipkg.name == name && ipkg.version.version_normalized == version_normalized)
             .map(|ipkg| ipkg.version)
@@ -509,7 +509,7 @@ impl LockFileGenerationRequest {
         name: &str,
         version_normalized: &str,
     ) -> Option<PackagistVersion> {
-        crate::composer_repo::collect_composer_packages(&self.composer_json.repositories)
+        super::composer_repo::collect_composer_packages(&self.composer_json.repositories)
             .into_iter()
             .find(|cpkg| cpkg.name == name && cpkg.version.version_normalized == version_normalized)
             .map(|cpkg| cpkg.version)
@@ -990,7 +990,7 @@ pub async fn generate_lock_file(request: &LockFileGenerationRequest) -> anyhow::
             continue;
         }
 
-        let queries = [crate::repository::PackageQuery {
+        let queries = [super::repository::PackageQuery {
             name: pkg.name.as_str(),
             constraint: None,
         }];
@@ -1327,13 +1327,13 @@ mod tests {
             replace: BTreeMap::new(),
             provide: BTreeMap::new(),
             conflict: BTreeMap::new(),
-            dist: Some(crate::packagist::PackagistDist {
+            dist: Some(super::super::packagist::PackagistDist {
                 dist_type: "zip".to_string(),
                 url: format!("https://example.com/{version}.zip"),
                 reference: Some("deadbeef".to_string()),
                 shasum: Some("abc123".to_string()),
             }),
-            source: Some(crate::packagist::PackagistSource {
+            source: Some(super::super::packagist::PackagistSource {
                 source_type: "git".to_string(),
                 url: "https://github.com/example/pkg.git".to_string(),
                 reference: Some("deadbeef".to_string()),
@@ -1684,7 +1684,10 @@ mod tests {
             composer_json,
             include_dev: true,
             repositories: std::sync::Arc::new(RepositorySet::with_packagist(
-                crate::cache::Cache::new(std::env::temp_dir().join("mozart-test-cache"), false),
+                super::super::cache::Cache::new(
+                    std::env::temp_dir().join("mozart-test-cache"),
+                    false,
+                ),
             )),
             previous_lock: None,
             lock_pinned_names: IndexSet::new(),
@@ -1779,10 +1782,10 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn test_generate_lock_file_monolog() {
-        use crate::cache::Cache;
-        use crate::resolver::PlatformConfig;
-        use crate::resolver::{ResolveRequest, resolve};
-        use mozart_core::package::Stability;
+        use super::super::super::package::Stability;
+        use super::super::cache::Cache;
+        use super::super::resolver::PlatformConfig;
+        use super::super::resolver::{ResolveRequest, resolve};
         use std::sync::Arc;
 
         // Resolve monolog/monolog ^3.0
@@ -1928,8 +1931,8 @@ mod tests {
     fn root_with_require(
         require: &[(&str, &str)],
         require_dev: &[(&str, &str)],
-    ) -> mozart_core::package::RawPackageData {
-        let mut root = mozart_core::package::RawPackageData::new("__root__".to_string());
+    ) -> crate::package::RawPackageData {
+        let mut root = crate::package::RawPackageData::new("__root__".to_string());
         for (k, v) in require {
             root.require.insert((*k).to_string(), (*v).to_string());
         }
diff --git a/crates/mozart-registry/src/packagist.rs b/crates/mozart-core/src/repository/packagist.rs
index 5c99b07..199ff51 100644
--- a/crates/mozart-registry/src/packagist.rs
+++ b/crates/mozart-core/src/repository/packagist.rs
@@ -1,4 +1,4 @@
-use crate::cache::Cache;
+use super::cache::Cache;
 use serde::de::Deserializer;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -248,7 +248,7 @@ pub async fn fetch_package_versions(
     // Cache miss — fetch from Packagist
     let url = format!("https://repo.packagist.org/p2/{package_name}.json");
     tracing::debug!(%url, "fetching package metadata");
-    let client = mozart_core::http::client_builder().build()?;
+    let client = crate::http::client_builder().build()?;
     let response = client.get(&url).send().await?;
     tracing::debug!(status = %response.status(), "received response");
 
@@ -318,7 +318,7 @@ pub async fn search_packages(
     query: &str,
     package_type: Option<&str>,
 ) -> anyhow::Result<(Vec<SearchResult>, u64)> {
-    let client = mozart_core::http::client_builder().build()?;
+    let client = crate::http::client_builder().build()?;
 
     let mut all_results: Vec<SearchResult> = Vec::new();
     let mut page = 1usize;
@@ -402,7 +402,7 @@ pub async fn fetch_package_names(
         url.push_str(&url_encode(t));
     }
     tracing::debug!(%url, "fetching package list");
-    let client = mozart_core::http::client_builder().build()?;
+    let client = crate::http::client_builder().build()?;
     let response = client.get(&url).send().await?;
     tracing::debug!(status = %response.status(), "received response");
 
@@ -500,7 +500,7 @@ pub struct SecurityAdvisoriesResponse {
 pub async fn fetch_security_advisories(
     package_names: &[&str],
 ) -> anyhow::Result<BTreeMap<String, Vec<SecurityAdvisory>>> {
-    let client = mozart_core::http::client_builder().build()?;
+    let client = crate::http::client_builder().build()?;
 
     let mut all_advisories: BTreeMap<String, Vec<SecurityAdvisory>> = BTreeMap::new();
 
diff --git a/crates/mozart-registry/src/path_repository.rs b/crates/mozart-core/src/repository/path_repository.rs
index bf71315..a96141c 100644
--- a/crates/mozart-registry/src/path_repository.rs
+++ b/crates/mozart-core/src/repository/path_repository.rs
@@ -21,7 +21,7 @@
 
 use std::path::{Path, PathBuf};
 
-use mozart_core::package::RawRepository;
+use crate::package::RawRepository;
 use mozart_php_serialize::{Value as PhpValue, serialize as php_serialize};
 use sha1::{Digest, Sha1};
 
diff --git a/crates/mozart-registry/src/repository/inline_package_repo.rs b/crates/mozart-core/src/repository/repository/inline_package_repo.rs
index 1043559..d65ee94 100644
--- a/crates/mozart-registry/src/repository/inline_package_repo.rs
+++ b/crates/mozart-core/src/repository/repository/inline_package_repo.rs
@@ -11,9 +11,9 @@
 //! Replacement satisfaction happens later in the solver once the replacing
 //! package is loaded transitively.
 
+use super::super::inline_package::{InlinePackage, collect_inline_packages};
 use super::{LoadResult, NamedPackagistVersion, PackageQuery, Repository};
-use crate::inline_package::{InlinePackage, collect_inline_packages};
-use mozart_core::package::RawRepository;
+use crate::package::RawRepository;
 
 pub struct InlinePackageRepository {
     id: String,
diff --git a/crates/mozart-registry/src/repository/mod.rs b/crates/mozart-core/src/repository/repository/mod.rs
index 46f62f0..4afff54 100644
--- a/crates/mozart-registry/src/repository/mod.rs
+++ b/crates/mozart-core/src/repository/repository/mod.rs
@@ -12,8 +12,8 @@
 
 use std::collections::BTreeMap;
 
-use crate::advisory::{MatchedAdvisory, PackageInfo};
-use crate::packagist::{PackagistVersion, SearchResult};
+use super::advisory::{MatchedAdvisory, PackageInfo};
+use super::packagist::{PackagistVersion, SearchResult};
 
 pub mod inline_package_repo;
 pub mod packagist_repo;
@@ -120,7 +120,7 @@ impl RepositorySet {
     /// Production default: a single [`packagist_repo::PackagistRepository`]
     /// backed by the given on-disk cache. Mirrors what Composer does when
     /// no `'packagist' => false` entry appears in the merged config.
-    pub fn with_packagist(repo_cache: crate::cache::Cache) -> Self {
+    pub fn with_packagist(repo_cache: super::cache::Cache) -> Self {
         Self::new(vec![Box::new(packagist_repo::PackagistRepository::new(
             repo_cache,
         ))])
@@ -210,7 +210,7 @@ impl RepositorySet {
         let names: Vec<&str> = packages.iter().map(|p| p.name.as_str()).collect();
 
         let (raw_advisories, unreachable_repos) =
-            match crate::packagist::fetch_security_advisories(&names).await {
+            match super::packagist::fetch_security_advisories(&names).await {
                 Ok(a) => (a, vec![]),
                 Err(e) if ignore_unreachable => {
                     tracing::warn!("Packagist advisory fetch failed (ignored): {e}");
@@ -259,7 +259,7 @@ fn normalize_or_separator(constraint: &str) -> String {
 ///
 /// Mirrors the version-matching step inside Composer's repository advisory fetch.
 fn version_filter_advisories(
-    all_advisories: &BTreeMap<String, Vec<crate::packagist::SecurityAdvisory>>,
+    all_advisories: &BTreeMap<String, Vec<super::packagist::SecurityAdvisory>>,
     packages: &[PackageInfo],
 ) -> BTreeMap<String, Vec<MatchedAdvisory>> {
     let mut result: BTreeMap<String, Vec<MatchedAdvisory>> = BTreeMap::new();
diff --git a/crates/mozart-registry/src/repository/packagist_repo.rs b/crates/mozart-core/src/repository/repository/packagist_repo.rs
index fa656b7..b221b0f 100644
--- a/crates/mozart-registry/src/repository/packagist_repo.rs
+++ b/crates/mozart-core/src/repository/repository/packagist_repo.rs
@@ -5,10 +5,10 @@
 //! direct call. Construction takes ownership of the [`Cache`] handle so
 //! callers no longer thread it through `ResolveRequest` / `LockFileGenerationRequest`.
 
+use super::super::cache::Cache;
+use super::super::packagist;
+use super::super::packagist::SearchResult;
 use super::{LoadResult, NamedPackagistVersion, PackageQuery, Repository, SearchMode};
-use crate::cache::Cache;
-use crate::packagist;
-use crate::packagist::SearchResult;
 
 pub struct PackagistRepository {
     id: String,
diff --git a/crates/mozart-registry/src/repository/vcs_repo.rs b/crates/mozart-core/src/repository/repository/vcs_repo.rs
index fff5f6f..760b8e5 100644
--- a/crates/mozart-registry/src/repository/vcs_repo.rs
+++ b/crates/mozart-core/src/repository/repository/vcs_repo.rs
@@ -5,10 +5,10 @@
 //! and serve subsequent queries from the in-memory cache. Mirrors
 //! `Composer\Repository\Vcs\VcsRepository`'s lazy-then-memoized behavior.
 
+use super::super::packagist::PackagistVersion;
+use super::super::vcs_bridge::{scan_vcs_repositories, vcs_to_packagist_version};
 use super::{LoadResult, NamedPackagistVersion, PackageQuery, Repository};
-use crate::packagist::PackagistVersion;
-use crate::vcs_bridge::{scan_vcs_repositories, vcs_to_packagist_version};
-use mozart_core::package::RawRepository;
+use crate::package::RawRepository;
 
 pub struct VcsRepository {
     id: String,
diff --git a/crates/mozart-registry/src/repository_filter.rs b/crates/mozart-core/src/repository/repository_filter.rs
index facbb36..814d297 100644
--- a/crates/mozart-registry/src/repository_filter.rs
+++ b/crates/mozart-core/src/repository/repository_filter.rs
@@ -6,7 +6,7 @@
 //! semantics for inline `type: package` and local `type: composer`
 //! repositories, since the installer fixtures rely on them.
 
-use mozart_core::package::RawRepository;
+use crate::package::RawRepository;
 use regex::Regex;
 
 /// Resolved filter for a single `repositories[]` entry.
diff --git a/crates/mozart-registry/src/resolver.rs b/crates/mozart-core/src/repository/resolver.rs
index dc9c6dd..1b06f9b 100644
--- a/crates/mozart-registry/src/resolver.rs
+++ b/crates/mozart-core/src/repository/resolver.rs
@@ -4,22 +4,21 @@
 //! candidate packages, generates SAT rules, and runs the CDCL solver to find
 //! a compatible set of packages to install.
 
+use super::packagist;
+use super::repository::{PackageQuery, RepositorySet};
+use super::vcs_bridge;
+use crate::dependency_resolver::{
+    DefaultPolicy, PoolBuilder, PoolLink, PoolPackageInput, RuleSetGenerator, Solver,
+    make_pool_links,
+};
+use crate::package::{RawRepository, Stability};
 use indexmap::{IndexMap, IndexSet};
+use mozart_semver::{Version, VersionConstraint};
 use regex::{Captures, Regex};
 use std::fmt;
 use std::sync::Arc;
 use std::sync::LazyLock;
 
-use crate::packagist;
-use crate::repository::{PackageQuery, RepositorySet};
-use crate::vcs_bridge;
-use mozart_core::package::{RawRepository, Stability};
-use mozart_sat_resolver::{
-    DefaultPolicy, PoolBuilder, PoolLink, PoolPackageInput, RuleSetGenerator, Solver,
-    make_pool_links,
-};
-use mozart_semver::{Version, VersionConstraint};
-
 /// Strip a `@stability` suffix from a constraint string and return the
 /// cleaned constraint plus the parsed stability. Mirrors Composer's
 /// `RootPackageLoader::extractStabilityFlags` (single-constraint case):
@@ -370,7 +369,7 @@ impl PackageName {
 
     /// Returns true if this is a platform package (php, ext-*, lib-*, composer pseudo packages).
     pub fn is_platform(&self) -> bool {
-        mozart_core::platform::is_platform_package(&self.0)
+        crate::platform::is_platform_package(&self.0)
     }
 
     /// Returns true if this is the virtual root package.
@@ -394,7 +393,7 @@ impl Default for PlatformConfig {
 impl PlatformConfig {
     /// Detect platform packages from the local PHP installation.
     pub fn new() -> Self {
-        let detected = mozart_core::platform::detect_platform();
+        let detected = crate::platform::detect_platform();
         let mut packages = IndexMap::new();
         for pkg in detected {
             packages.insert(pkg.name, pkg.version);
@@ -503,7 +502,7 @@ fn should_skip_platform_dep(
     }
     ignore_platform_req_list
         .iter()
-        .any(|p| mozart_core::matches_wildcard(dep_name, p))
+        .any(|p| crate::matches_wildcard(dep_name, p))
 }
 
 /// Mirrors `Composer\Package\CompletePackage::isAbandoned`: any
@@ -1184,8 +1183,8 @@ pub async fn resolve(request: &ResolveRequest) -> Result<Vec<ResolvedPackage>, R
     // pick a replacer that nothing required by name (e.g.
     // `broken-deps-do-not-replace.test`), where Composer would correctly
     // surface the broken dependency instead.
-    let inline_packages = crate::inline_package::collect_inline_packages(&request.raw_repositories);
-    let mut inline_packages_by_name: IndexMap<String, Vec<&crate::inline_package::InlinePackage>> =
+    let inline_packages = super::inline_package::collect_inline_packages(&request.raw_repositories);
+    let mut inline_packages_by_name: IndexMap<String, Vec<&super::inline_package::InlinePackage>> =
         IndexMap::new();
     for ipkg in &inline_packages {
         inline_packages_by_name
@@ -1198,7 +1197,7 @@ pub async fn resolve(request: &ResolveRequest) -> Result<Vec<ResolvedPackage>, R
     // version listed by a repository's `security-advisories` is removed
     // from the pool before solving.
     let security_advisories =
-        crate::inline_package::collect_security_advisories(&request.raw_repositories);
+        super::inline_package::collect_security_advisories(&request.raw_repositories);
     let security_blocks_version = |name: &str, version_normalized: &str| -> bool {
         if !request.block_insecure {
             return false;
@@ -1286,7 +1285,7 @@ pub async fn resolve(request: &ResolveRequest) -> Result<Vec<ResolvedPackage>, R
     // as inline packages — they bypass the RepositorySet and go straight
     // into the pool, with names recorded so Packagist loops skip them.
     let composer_repo_packages =
-        crate::composer_repo::collect_composer_packages(&request.raw_repositories);
+        super::composer_repo::collect_composer_packages(&request.raw_repositories);
     let mut composer_repo_names: IndexSet<String> = IndexSet::new();
     for cpkg in &composer_repo_packages {
         composer_repo_names.insert(cpkg.name.clone());
@@ -1900,7 +1899,7 @@ mod tests {
 
     #[test]
     fn test_sat_resolve_simple_offline() {
-        use mozart_sat_resolver::*;
+        use crate::dependency_resolver::*;
 
         let mut pool = Pool::new(
             vec![
@@ -1952,7 +1951,7 @@ mod tests {
     #[tokio::test]
     #[ignore]
     async fn test_resolve_monolog_e2e() {
-        use crate::cache::Cache;
+        use super::super::cache::Cache;
         let request = ResolveRequest {
             root_name: String::new(),
             root_version: None,
diff --git a/crates/mozart-registry/src/vcs_bridge.rs b/crates/mozart-core/src/repository/vcs_bridge.rs
index aae3d87..37d066b 100644
--- a/crates/mozart-registry/src/vcs_bridge.rs
+++ b/crates/mozart-core/src/repository/vcs_bridge.rs
@@ -3,17 +3,15 @@
 //! Scans VCS repositories defined in composer.json and converts
 //! discovered package versions into pool inputs for the SAT resolver.
 
+use super::packagist::PackagistVersion;
+use super::resolver::{parse_normalized, version_stability};
+use crate::dependency_resolver::{PoolPackageInput, make_pool_links};
+use crate::package::{RawRepository, Stability};
+use crate::vcs::driver::DriverConfig;
+use crate::vcs::repository::{VcsPackageVersion, VcsRepository};
 use indexmap::IndexMap;
 use std::collections::BTreeMap;
 
-use mozart_core::package::{RawRepository, Stability};
-use mozart_sat_resolver::{PoolPackageInput, make_pool_links};
-use mozart_vcs::driver::DriverConfig;
-use mozart_vcs::repository::{VcsPackageVersion, VcsRepository};
-
-use crate::packagist::PackagistVersion;
-use crate::resolver::{parse_normalized, version_stability};
-
 /// Scan all VCS-type repositories and collect package versions.
 ///
 /// Non-VCS repos (e.g. "composer", "package") are silently skipped.
@@ -134,13 +132,13 @@ pub fn vcs_to_packagist_version(vpkg: &VcsPackageVersion) -> PackagistVersion {
         replace: extract_dep_map(&vpkg.composer_json, "replace"),
         provide: extract_dep_map(&vpkg.composer_json, "provide"),
         conflict: extract_dep_map(&vpkg.composer_json, "conflict"),
-        dist: vpkg.dist.as_ref().map(|d| crate::packagist::PackagistDist {
+        dist: vpkg.dist.as_ref().map(|d| super::packagist::PackagistDist {
             dist_type: d.dist_type.clone(),
             url: d.url.clone(),
             reference: Some(d.reference.clone()),
             shasum: d.shasum.clone(),
         }),
-        source: Some(crate::packagist::PackagistSource {
+        source: Some(super::packagist::PackagistSource {
             source_type: vpkg.source.source_type.clone(),
             url: vpkg.source.url.clone(),
             reference: Some(vpkg.source.reference.clone()),
diff --git a/crates/mozart-registry/src/version.rs b/crates/mozart-core/src/repository/version.rs
index 9a7c6e6..143131a 100644
--- a/crates/mozart-registry/src/version.rs
+++ b/crates/mozart-core/src/repository/version.rs
@@ -1,5 +1,5 @@
-use crate::packagist::PackagistVersion;
-use mozart_core::package::Stability;
+use super::super::package::Stability;
+use super::packagist::PackagistVersion;
 use std::cmp::Ordering;
 
 /// Determine the stability of a normalized version string.
diff --git a/crates/mozart-registry/src/version_selector.rs b/crates/mozart-core/src/repository/version_selector.rs
index 7aa409e..506c503 100644
--- a/crates/mozart-registry/src/version_selector.rs
+++ b/crates/mozart-core/src/repository/version_selector.rs
@@ -1,7 +1,7 @@
-use crate::cache::Cache;
-use crate::packagist::{self, PackagistVersion};
-use crate::version;
-use mozart_core::package::Stability;
+use super::super::package::Stability;
+use super::cache::Cache;
+use super::packagist::{self, PackagistVersion};
+use super::version;
 
 /// Mirrors `Composer\Package\Version\VersionSelector`.
 pub struct VersionSelector {
diff --git a/crates/mozart-vcs/src/lib.rs b/crates/mozart-core/src/vcs.rs
index e7ca383..e7ca383 100644
--- a/crates/mozart-vcs/src/lib.rs
+++ b/crates/mozart-core/src/vcs.rs
diff --git a/crates/mozart-vcs/src/downloader/git.rs b/crates/mozart-core/src/vcs/downloader/git.rs
index 814d67e..eb7a649 100644
--- a/crates/mozart-vcs/src/downloader/git.rs
+++ b/crates/mozart-core/src/vcs/downloader/git.rs
@@ -1,13 +1,10 @@
-use std::path::Path;
-use std::sync::LazyLock;
-
+use super::super::process::ProcessExecutor;
+use super::super::util::git::GitUtil;
+use super::VcsDownloader;
 use anyhow::Result;
 use regex::Regex;
-
-use crate::process::ProcessExecutor;
-use crate::util::git::GitUtil;
-
-use super::VcsDownloader;
+use std::path::Path;
+use std::sync::LazyLock;
 
 /// Match `<hex> HEAD` lines in `git show-ref --head -d` output.
 static HEAD_REF_RE: LazyLock<Regex> =
diff --git a/crates/mozart-vcs/src/downloader/hg.rs b/crates/mozart-core/src/vcs/downloader/hg.rs
index 3230404..33650f8 100644
--- a/crates/mozart-vcs/src/downloader/hg.rs
+++ b/crates/mozart-core/src/vcs/downloader/hg.rs
@@ -1,10 +1,7 @@
-use std::path::Path;
-
-use anyhow::Result;
-
-use crate::util::hg::HgUtil;
-
+use super::super::util::hg::HgUtil;
 use super::VcsDownloader;
+use anyhow::Result;
+use std::path::Path;
 
 /// Mercurial downloader using clone/pull/update.
 pub struct HgDownloader {
diff --git a/crates/mozart-vcs/src/downloader/mod.rs b/crates/mozart-core/src/vcs/downloader/mod.rs
index 352f330..352f330 100644
--- a/crates/mozart-vcs/src/downloader/mod.rs
+++ b/crates/mozart-core/src/vcs/downloader/mod.rs
diff --git a/crates/mozart-vcs/src/downloader/svn.rs b/crates/mozart-core/src/vcs/downloader/svn.rs
index 87b59da..ea885ed 100644
--- a/crates/mozart-vcs/src/downloader/svn.rs
+++ b/crates/mozart-core/src/vcs/downloader/svn.rs
@@ -1,12 +1,9 @@
-use std::path::Path;
-use std::sync::LazyLock;
-
+use super::super::util::svn::SvnUtil;
+use super::VcsDownloader;
 use anyhow::Result;
 use regex::Regex;
-
-use crate::util::svn::SvnUtil;
-
-use super::VcsDownloader;
+use std::path::Path;
+use std::sync::LazyLock;
 
 /// Match any non-`X` status line (mirror of Composer's
 /// `{^ *[^X ] +}m`). Ignores externals (`X` prefix).
diff --git a/crates/mozart-vcs/src/driver/bitbucket.rs b/crates/mozart-core/src/vcs/driver/bitbucket.rs
index 0e67bc8..2235e10 100644
--- a/crates/mozart-vcs/src/driver/bitbucket.rs
+++ b/crates/mozart-core/src/vcs/driver/bitbucket.rs
@@ -37,7 +37,7 @@ impl BitbucketDriver {
             branches: None,
             info_cache: IndexMap::new(),
             git_driver: None,
-            http_client: mozart_core::http::default_client(),
+            http_client: crate::http::default_client(),
             config,
             api_failed: false,
             vcs_type: "git".to_string(),
diff --git a/crates/mozart-vcs/src/driver/forgejo.rs b/crates/mozart-core/src/vcs/driver/forgejo.rs
index 665c177..8a290c0 100644
--- a/crates/mozart-vcs/src/driver/forgejo.rs
+++ b/crates/mozart-core/src/vcs/driver/forgejo.rs
@@ -42,7 +42,7 @@ impl ForgejoDriver {
             branches: None,
             info_cache: IndexMap::new(),
             git_driver: None,
-            http_client: mozart_core::http::default_client(),
+            http_client: crate::http::default_client(),
             config,
             api_failed: false,
         }
diff --git a/crates/mozart-vcs/src/driver/git.rs b/crates/mozart-core/src/vcs/driver/git.rs
index 090a5fa..7d6643f 100644
--- a/crates/mozart-vcs/src/driver/git.rs
+++ b/crates/mozart-core/src/vcs/driver/git.rs
@@ -1,14 +1,11 @@
+use super::super::process::ProcessExecutor;
+use super::super::util::git::GitUtil;
+use super::{DistReference, DriverConfig, SourceReference, VcsDriver};
+use anyhow::Result;
 use indexmap::IndexMap;
 use std::collections::BTreeMap;
 use std::path::{Path, PathBuf};
 
-use anyhow::Result;
-
-use crate::process::ProcessExecutor;
-use crate::util::git::GitUtil;
-
-use super::{DistReference, DriverConfig, SourceReference, VcsDriver};
-
 /// Git VCS driver.
 ///
 /// Corresponds to Composer's `Repository\Vcs\GitDriver`.
diff --git a/crates/mozart-vcs/src/driver/github.rs b/crates/mozart-core/src/vcs/driver/github.rs
index e968c3e..7772bbb 100644
--- a/crates/mozart-vcs/src/driver/github.rs
+++ b/crates/mozart-core/src/vcs/driver/github.rs
@@ -40,7 +40,7 @@ impl GitHubDriver {
             repo_data: None,
             info_cache: IndexMap::new(),
             git_driver: None,
-            http_client: mozart_core::http::default_client(),
+            http_client: crate::http::default_client(),
             config,
             api_failed: false,
         }
diff --git a/crates/mozart-vcs/src/driver/gitlab.rs b/crates/mozart-core/src/vcs/driver/gitlab.rs
index 937251a..f181e63 100644
--- a/crates/mozart-vcs/src/driver/gitlab.rs
+++ b/crates/mozart-core/src/vcs/driver/gitlab.rs
@@ -44,7 +44,7 @@ impl GitLabDriver {
             branches: None,
             info_cache: IndexMap::new(),
             git_driver: None,
-            http_client: mozart_core::http::default_client(),
+            http_client: crate::http::default_client(),
             config,
             api_failed: false,
         }
diff --git a/crates/mozart-vcs/src/driver/hg.rs b/crates/mozart-core/src/vcs/driver/hg.rs
index f476e6a..e2c3fcd 100644
--- a/crates/mozart-vcs/src/driver/hg.rs
+++ b/crates/mozart-core/src/vcs/driver/hg.rs
@@ -1,14 +1,11 @@
+use super::super::process::ProcessExecutor;
+use super::super::util::hg::HgUtil;
+use super::{DistReference, DriverConfig, SourceReference, VcsDriver};
+use anyhow::Result;
 use indexmap::IndexMap;
 use std::collections::BTreeMap;
 use std::path::PathBuf;
 
-use anyhow::Result;
-
-use crate::process::ProcessExecutor;
-use crate::util::hg::HgUtil;
-
-use super::{DistReference, DriverConfig, SourceReference, VcsDriver};
-
 /// Mercurial VCS driver.
 ///
 /// Corresponds to Composer's `Repository\Vcs\HgDriver`.
@@ -53,7 +50,7 @@ impl VcsDriver for HgDriver {
     async fn initialize(&mut self) -> Result<()> {
         let cache_dir = &self.config.cache_vcs_dir;
         std::fs::create_dir_all(cache_dir)?;
-        let repo_dir = cache_dir.join(crate::util::git::GitUtil::sanitize_url(&self.url));
+        let repo_dir = cache_dir.join(super::super::util::git::GitUtil::sanitize_url(&self.url));
 
         if repo_dir.join(".hg").is_dir() {
             // Update existing clone
diff --git a/crates/mozart-vcs/src/driver/mod.rs b/crates/mozart-core/src/vcs/driver/mod.rs
index cfaf11e..cfaf11e 100644
--- a/crates/mozart-vcs/src/driver/mod.rs
+++ b/crates/mozart-core/src/vcs/driver/mod.rs
diff --git a/crates/mozart-vcs/src/driver/svn.rs b/crates/mozart-core/src/vcs/driver/svn.rs
index 16363e1..7ba9e86 100644
--- a/crates/mozart-vcs/src/driver/svn.rs
+++ b/crates/mozart-core/src/vcs/driver/svn.rs
@@ -1,13 +1,10 @@
-use indexmap::IndexMap;
-use std::collections::BTreeMap;
-
+use super::super::process::ProcessExecutor;
+use super::super::util::svn::SvnUtil;
+use super::{DistReference, DriverConfig, SourceReference, VcsDriver};
 use anyhow::Result;
+use indexmap::IndexMap;
 use regex::Regex;
-
-use crate::process::ProcessExecutor;
-use crate::util::svn::SvnUtil;
-
-use super::{DistReference, DriverConfig, SourceReference, VcsDriver};
+use std::collections::BTreeMap;
 
 /// SVN VCS driver.
 ///
diff --git a/crates/mozart-vcs/src/process.rs b/crates/mozart-core/src/vcs/process.rs
index 8ccc11d..8ccc11d 100644
--- a/crates/mozart-vcs/src/process.rs
+++ b/crates/mozart-core/src/vcs/process.rs
diff --git a/crates/mozart-vcs/src/repository.rs b/crates/mozart-core/src/vcs/repository.rs
index b941eec..55f98f9 100644
--- a/crates/mozart-vcs/src/repository.rs
+++ b/crates/mozart-core/src/vcs/repository.rs
@@ -1,8 +1,7 @@
-use anyhow::{Result, bail};
-
-use crate::driver::{
+use super::driver::{
     DistReference, DriverConfig, DriverType, SourceReference, create_driver, detect_driver,
 };
+use anyhow::{Result, bail};
 
 /// A single package version discovered from a VCS repository.
 #[derive(Debug, Clone)]
diff --git a/crates/mozart-vcs/src/util/git.rs b/crates/mozart-core/src/vcs/util/git.rs
index ab4366d..15bfa09 100644
--- a/crates/mozart-vcs/src/util/git.rs
+++ b/crates/mozart-core/src/vcs/util/git.rs
@@ -1,10 +1,8 @@
-use std::path::{Path, PathBuf};
-use std::sync::LazyLock;
-
+use super::super::process::{ProcessExecutor, ProcessOutput};
 use anyhow::{Result, bail};
 use regex::Regex;
-
-use crate::process::{ProcessExecutor, ProcessOutput};
+use std::path::{Path, PathBuf};
+use std::sync::LazyLock;
 
 /// Modern GitHub token pattern (40+ hex chars, `ghp_…`, `github_pat_…`).
 ///
diff --git a/crates/mozart-vcs/src/util/hg.rs b/crates/mozart-core/src/vcs/util/hg.rs
index 7f5abcc..73051b7 100644
--- a/crates/mozart-vcs/src/util/hg.rs
+++ b/crates/mozart-core/src/vcs/util/hg.rs
@@ -1,8 +1,6 @@
-use std::path::Path;
-
+use super::super::process::{ProcessExecutor, ProcessOutput};
 use anyhow::Result;
-
-use crate::process::{ProcessExecutor, ProcessOutput};
+use std::path::Path;
 
 /// Mercurial utility for command execution.
 pub struct HgUtil {
diff --git a/crates/mozart-vcs/src/util/mod.rs b/crates/mozart-core/src/vcs/util/mod.rs
index b2c35fc..b2c35fc 100644
--- a/crates/mozart-vcs/src/util/mod.rs
+++ b/crates/mozart-core/src/vcs/util/mod.rs
diff --git a/crates/mozart-vcs/src/util/svn.rs b/crates/mozart-core/src/vcs/util/svn.rs
index e9a6813..d989fc8 100644
--- a/crates/mozart-vcs/src/util/svn.rs
+++ b/crates/mozart-core/src/vcs/util/svn.rs
@@ -1,8 +1,6 @@
-use std::path::Path;
-
+use super::super::process::{ProcessExecutor, ProcessOutput};
 use anyhow::Result;
-
-use crate::process::{ProcessExecutor, ProcessOutput};
+use std::path::Path;
 
 /// SVN credentials for authenticated operations.
 #[derive(Debug, Clone)]
diff --git a/crates/mozart-vcs/src/version_guesser.rs b/crates/mozart-core/src/vcs/version_guesser.rs
index 038e332..58b758e 100644
--- a/crates/mozart-vcs/src/version_guesser.rs
+++ b/crates/mozart-core/src/vcs/version_guesser.rs
@@ -8,15 +8,12 @@
 //!   Composer parallelises via `executeAsync`; ours is simpler at the
 //!   cost of speed when many candidate branches exist.
 
-use std::path::Path;
-use std::sync::LazyLock;
-
+use super::process::ProcessExecutor;
+use mozart_semver::{Version, normalize_branch};
 use regex::Regex;
 use serde_json::Value;
-
-use mozart_semver::{Version, normalize_branch};
-
-use crate::process::ProcessExecutor;
+use std::path::Path;
+use std::sync::LazyLock;
 
 const DEFAULT_BRANCH_ALIAS: &str = "9999999-dev";
 
diff --git a/crates/mozart-vcs/tests/git_driver_test.rs b/crates/mozart-core/tests/git_driver_test.rs
index dd72ad6..c0dd4af 100644
--- a/crates/mozart-vcs/tests/git_driver_test.rs
+++ b/crates/mozart-core/tests/git_driver_test.rs
@@ -1,14 +1,13 @@
+use mozart_core::vcs::downloader::VcsDownloader;
+use mozart_core::vcs::downloader::git::GitDownloader;
+use mozart_core::vcs::driver::{DriverConfig, DriverType, create_driver};
+use mozart_core::vcs::process::ProcessExecutor;
+use mozart_core::vcs::repository::VcsRepository;
+use mozart_core::vcs::util::git::GitUtil;
 use std::path::Path;
 use std::process::Command;
-
 use tempfile::TempDir;
 
-use mozart_vcs::downloader::VcsDownloader;
-use mozart_vcs::downloader::git::GitDownloader;
-use mozart_vcs::driver::{DriverConfig, DriverType, create_driver};
-use mozart_vcs::process::ProcessExecutor;
-use mozart_vcs::util::git::GitUtil;
-
 fn has_git() -> bool {
     Command::new("git").arg("--version").output().is_ok()
 }
@@ -251,7 +250,7 @@ fn test_git_downloader_unpushed_changes() {
 
 #[test]
 fn test_detect_driver() {
-    use mozart_vcs::driver::{DriverType, detect_driver};
+    use mozart_core::vcs::driver::{DriverType, detect_driver};
 
     let config = DriverConfig::default();
 
@@ -307,11 +306,7 @@ async fn test_vcs_repository_scan() {
         ..DriverConfig::default()
     };
 
-    let repo = mozart_vcs::repository::VcsRepository::new(
-        repo_dir.path().to_str().unwrap().to_string(),
-        None,
-        config,
-    );
+    let repo = VcsRepository::new(repo_dir.path().to_str().unwrap().to_string(), None, config);
 
     let versions = repo.scan().await.unwrap();
     assert!(!versions.is_empty(), "No versions found");
diff --git a/crates/mozart-registry/Cargo.toml b/crates/mozart-registry/Cargo.toml
deleted file mode 100644
index 6239973..0000000
--- a/crates/mozart-registry/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "mozart-registry"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-mozart-console-macros.workspace = true
-mozart-core.workspace = true
-mozart-metadata-minifier.workspace = true
-mozart-php-serialize.workspace = true
-mozart-sat-resolver.workspace = true
-mozart-semver.workspace = true
-mozart-vcs.workspace = true
-anyhow.workspace = true
-async-trait.workspace = true
-filetime.workspace = true
-flate2.workspace = true
-indexmap.workspace = true
-md5.workspace = true
-regex.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-sha1.workspace = true
-tar.workspace = true
-tempfile.workspace = true
-tokio.workspace = true
-tracing.workspace = true
-zip.workspace = true
-
-[dev-dependencies]
-mozart-test-harness.workspace = true
diff --git a/crates/mozart-registry/tests/poolbuilder.rs b/crates/mozart-registry/tests/poolbuilder.rs
deleted file mode 100644
index d8511e4..0000000
--- a/crates/mozart-registry/tests/poolbuilder.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-//! Pool-builder fixture suite, ported from
-//! `composer/tests/Composer/Test/DependencyResolver/PoolBuilderTest.php`.
-//!
-//! Composer drives this suite through a `@dataProvider`; each `.test` file
-//! becomes one parameterized case. Mirrored here as one `#[test]` per
-//! fixture so the count surfaces in `cargo test` output and individual
-//! cases can be re-enabled as the runner is fleshed out.
-//!
-//! Every test is currently `#[ignore]` because the runner is a stub: the
-//! orchestration that takes a `RepositorySet` + `Request` and produces a
-//! populated `Pool` lives inline in `mozart_registry::resolver::resolve`,
-//! not as an extracted entry point. Wiring those up — alias handling,
-//! stability flags, fixed/locked packages, the optimizer pass — is the
-//! follow-up work this scaffolding exists to track.
-
-use std::path::{Path, PathBuf};
-
-use mozart_test_harness::{ParsedPoolBuilderTest, parse_pool_builder_test_file};
-
-fn fixtures_dir() -> PathBuf {
-    Path::new(env!("CARGO_MANIFEST_DIR"))
-        .join("../../composer/tests/Composer/Test/DependencyResolver/Fixtures/poolbuilder")
-}
-
-fn run_poolbuilder_fixture(ident: &str) {
-    let filename = format!("{}.test", ident.replace('_', "-"));
-    let path = fixtures_dir().join(&filename);
-    let _parsed: ParsedPoolBuilderTest = parse_pool_builder_test_file(&path)
-        .unwrap_or_else(|e| panic!("failed to parse {}: {:#}", path.display(), e));
-
-    // Runner is intentionally not implemented yet — see module docs.
-    // Removing `#[ignore]` from a case will surface this `unimplemented!`
-    // and force the missing pool-builder entry point into existence.
-    unimplemented!(
-        "PoolBuilderTest runner not yet wired up; cannot execute {}",
-        path.display()
-    );
-}
-
-macro_rules! poolbuilder_fixture {
-    ($name:ident) => {
-        #[test]
-        #[ignore]
-        fn $name() {
-            run_poolbuilder_fixture(stringify!($name));
-        }
-    };
-}
-
-poolbuilder_fixture!(alias_priority_conflicting);
-poolbuilder_fixture!(alias_with_reference);
-poolbuilder_fixture!(constraint_expansion_works_with_exact_versions);
-poolbuilder_fixture!(filter_impossible_packages);
-poolbuilder_fixture!(filter_impossible_packages_locked_replacer);
-poolbuilder_fixture!(filter_impossible_packages_only_required);
-poolbuilder_fixture!(filter_impossible_packages_only_required_provides);
-poolbuilder_fixture!(filter_impossible_packages_only_required_replaces);
-poolbuilder_fixture!(filter_impossible_packages_provides);
-poolbuilder_fixture!(filter_impossible_packages_replaces);
-poolbuilder_fixture!(fixed_packages_do_not_load_from_repos);
-poolbuilder_fixture!(fixed_packages_replaced_do_not_load_from_repos);
-poolbuilder_fixture!(load_replaced_package_if_replacer_dropped);
-poolbuilder_fixture!(load_replaced_root_package_if_replacer_dropped);
-poolbuilder_fixture!(multi_repo_replace);
-poolbuilder_fixture!(multi_repo_replace_partial_update_all);
-poolbuilder_fixture!(must_expand_root_reqs);
-poolbuilder_fixture!(package_versions_are_not_loaded_if_not_required_expansion);
-poolbuilder_fixture!(package_versions_are_not_loaded_if_not_required_recursive);
-poolbuilder_fixture!(packages_that_do_not_exist);
-poolbuilder_fixture!(partial_update);
-poolbuilder_fixture!(partial_update_transitive_deps_no_root_unfix);
-poolbuilder_fixture!(partial_update_transitive_deps_unfix);
-poolbuilder_fixture!(partial_update_unfixes_path_repo_replacer_with_transitive_deps);
-poolbuilder_fixture!(partial_update_unfixes_path_repos_always_but_not_their_transitive_deps);
-poolbuilder_fixture!(partial_update_unfixing_locked_deps);
-poolbuilder_fixture!(partial_update_unfixing_replacers);
-poolbuilder_fixture!(partial_update_unfixing_with_replacers);
-poolbuilder_fixture!(partial_update_unfixing_with_replacers_providers);
-poolbuilder_fixture!(root_requirements_avoid_loading_further_versions);
-poolbuilder_fixture!(stability_flags_take_over_minimum_stability_and_filter_packages);
diff --git a/crates/mozart-sat-resolver/Cargo.toml b/crates/mozart-sat-resolver/Cargo.toml
deleted file mode 100644
index 5b8a46c..0000000
--- a/crates/mozart-sat-resolver/Cargo.toml
+++ /dev/null
@@ -1,11 +0,0 @@
-[package]
-name = "mozart-sat-resolver"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-mozart-semver.workspace = true
-mozart-core.workspace = true
-indexmap.workspace = true
-
-[dev-dependencies]
diff --git a/crates/mozart-vcs/Cargo.toml b/crates/mozart-vcs/Cargo.toml
deleted file mode 100644
index 92b3e24..0000000
--- a/crates/mozart-vcs/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "mozart-vcs"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-mozart-core.workspace = true
-mozart-semver.workspace = true
-anyhow.workspace = true
-base64.workspace = true
-indexmap.workspace = true
-regex.workspace = true
-reqwest.workspace = true
-serde.workspace = true
-serde_json.workspace = true
-tokio.workspace = true
-tracing.workspace = true
-url.workspace = true
-
-[dev-dependencies]
-tempfile.workspace = true
diff --git a/crates/mozart/Cargo.toml b/crates/mozart/Cargo.toml
index 9a0e3eb..c1b10d6 100644
--- a/crates/mozart/Cargo.toml
+++ b/crates/mozart/Cargo.toml
@@ -4,14 +4,10 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-mozart-archiver.workspace = true
-mozart-autoload.workspace = true
 mozart-console-macros.workspace = true
 mozart-core.workspace = true
-mozart-registry.workspace = true
 mozart-semver.workspace = true
 mozart-spdx-licenses.workspace = true
-mozart-vcs.workspace = true
 anyhow.workspace = true
 clap.workspace = true
 clap_complete.workspace = true
@@ -26,9 +22,9 @@ sha1.workspace = true
 tempfile.workspace = true
 terminal_size.workspace = true
 tokio.workspace = true
-url.workspace = true
 tracing-subscriber.workspace = true
 tracing.workspace = true
+url.workspace = true
 
 [dev-dependencies]
 mozart-test-harness.workspace = true
diff --git a/crates/mozart/src/commands/archive.rs b/crates/mozart/src/commands/archive.rs
index 7e1697f..d83bdb5 100644
--- a/crates/mozart/src/commands/archive.rs
+++ b/crates/mozart/src/commands/archive.rs
@@ -1,8 +1,8 @@
 use crate::composer::Composer;
 use clap::Args;
-use mozart_archiver::{ArchiveManager, ArchivePackage};
 use mozart_core::console_writeln;
 use mozart_core::factory::create_config;
+use mozart_core::package::archiver::{ArchiveManager, ArchivePackage};
 use std::borrow::Cow;
 use std::path::{Path, PathBuf};
 
@@ -74,9 +74,9 @@ async fn archive(
     working_dir: &Path,
     no_cache: bool,
 ) -> anyhow::Result<()> {
-    let cache_config = mozart_registry::cache::build_cache_config(no_cache);
-    let repo_cache = mozart_registry::cache::Cache::repo(&cache_config);
-    let files_cache = mozart_registry::cache::Cache::files(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(no_cache);
+    let repo_cache = mozart_core::repository::cache::Cache::repo(&cache_config);
+    let files_cache = mozart_core::repository::cache::Cache::files(&cache_config);
 
     let archive_manager = ArchiveManager::new();
 
@@ -138,10 +138,10 @@ async fn select_package(
     io: &mozart_core::console::Console,
     package_name: &str,
     version: Option<&str>,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
 ) -> anyhow::Result<ArchivePackage> {
     use mozart_core::package::Stability;
-    use mozart_registry::version::find_best_candidate;
+    use mozart_core::repository::version::find_best_candidate;
 
     io.info("Searching for the specified package.");
 
@@ -160,7 +160,8 @@ async fn select_package(
     let version = version.as_deref();
 
     let packages =
-        mozart_registry::packagist::fetch_package_versions(package_name, repo_cache).await?;
+        mozart_core::repository::packagist::fetch_package_versions(package_name, repo_cache)
+            .await?;
     if packages.is_empty() {
         anyhow::bail!("No versions found for package \"{}\"", package_name);
     }
diff --git a/crates/mozart/src/commands/audit.rs b/crates/mozart/src/commands/audit.rs
index 30f0716..72d4408 100644
--- a/crates/mozart/src/commands/audit.rs
+++ b/crates/mozart/src/commands/audit.rs
@@ -4,9 +4,9 @@ use crate::composer::Composer;
 use clap::Args;
 use indexmap::IndexMap;
 use mozart_core::advisory::{AbandonedHandling, AuditConfig, AuditFormat};
-use mozart_registry::advisory::{AuditOptions, Auditor, PackageInfo};
-use mozart_registry::cache::{Cache, build_cache_config};
-use mozart_registry::repository::RepositorySet;
+use mozart_core::repository::advisory::{AuditOptions, Auditor, PackageInfo};
+use mozart_core::repository::cache::{Cache, build_cache_config};
+use mozart_core::repository::repository::RepositorySet;
 
 #[derive(Args)]
 pub struct AuditArgs {
@@ -127,7 +127,7 @@ fn get_packages(composer: &Composer, args: &AuditArgs) -> anyhow::Result<Vec<Pac
 
 fn load_installed_packages(working_dir: &Path, no_dev: bool) -> anyhow::Result<Vec<PackageInfo>> {
     let vendor_dir = working_dir.join("vendor");
-    let installed = mozart_registry::installed::InstalledPackages::read(&vendor_dir)?;
+    let installed = mozart_core::repository::installed::InstalledPackages::read(&vendor_dir)?;
 
     let dev_names: indexmap::IndexSet<String> = installed
         .dev_package_names
@@ -166,9 +166,9 @@ fn load_locked_packages(working_dir: &Path, no_dev: bool) -> anyhow::Result<Vec<
         );
     }
 
-    let lock = mozart_registry::lockfile::LockFile::read_from_file(&lock_path)?;
+    let lock = mozart_core::repository::lockfile::LockFile::read_from_file(&lock_path)?;
 
-    let mut all_packages: Vec<&mozart_registry::lockfile::LockedPackage> =
+    let mut all_packages: Vec<&mozart_core::repository::lockfile::LockedPackage> =
         lock.packages.iter().collect();
 
     if !no_dev && let Some(ref pkgs_dev) = lock.packages_dev {
@@ -196,7 +196,7 @@ mod tests {
     use std::collections::BTreeMap;
 
     use super::*;
-    use mozart_registry::lockfile::{LockFile, LockedPackage};
+    use mozart_core::repository::lockfile::{LockFile, LockedPackage};
 
     fn make_pkg(name: &str, version: &str, version_normalized: Option<&str>) -> PackageInfo {
         PackageInfo {
@@ -228,8 +228,8 @@ mod tests {
         let working_dir = dir.path();
         let vendor_dir = working_dir.join("vendor");
 
-        let mut installed = mozart_registry::installed::InstalledPackages::new();
-        installed.upsert(mozart_registry::installed::InstalledPackageEntry {
+        let mut installed = mozart_core::repository::installed::InstalledPackages::new();
+        installed.upsert(mozart_core::repository::installed::InstalledPackageEntry {
             name: "monolog/monolog".to_string(),
             version: "1.5.0".to_string(),
             version_normalized: Some("1.5.0.0".to_string()),
@@ -259,8 +259,8 @@ mod tests {
         let working_dir = dir.path();
         let vendor_dir = working_dir.join("vendor");
 
-        let mut installed = mozart_registry::installed::InstalledPackages::new();
-        installed.upsert(mozart_registry::installed::InstalledPackageEntry {
+        let mut installed = mozart_core::repository::installed::InstalledPackages::new();
+        installed.upsert(mozart_core::repository::installed::InstalledPackageEntry {
             name: "monolog/monolog".to_string(),
             version: "1.5.0".to_string(),
             version_normalized: None,
@@ -274,7 +274,7 @@ mod tests {
             support: None,
             extra_fields: BTreeMap::new(),
         });
-        installed.upsert(mozart_registry::installed::InstalledPackageEntry {
+        installed.upsert(mozart_core::repository::installed::InstalledPackageEntry {
             name: "phpunit/phpunit".to_string(),
             version: "10.0.0".to_string(),
             version_normalized: None,
diff --git a/crates/mozart/src/commands/browse.rs b/crates/mozart/src/commands/browse.rs
index a8ccab3..f646577 100644
--- a/crates/mozart/src/commands/browse.rs
+++ b/crates/mozart/src/commands/browse.rs
@@ -4,9 +4,9 @@ use mozart_core::console::Console;
 use mozart_core::console_writeln;
 use mozart_core::console_writeln_error;
 use mozart_core::exit_code;
-use mozart_registry::browse_repos::{BrowseRepos, CompletePackageView};
-use mozart_registry::cache::{Cache, build_cache_config};
-use mozart_registry::installed::InstalledPackages;
+use mozart_core::repository::browse_repos::{BrowseRepos, CompletePackageView};
+use mozart_core::repository::cache::{Cache, build_cache_config};
+use mozart_core::repository::installed::InstalledPackages;
 use std::process::Command;
 
 #[derive(Args)]
diff --git a/crates/mozart/src/commands/bump.rs b/crates/mozart/src/commands/bump.rs
index 4722fe2..ee611d1 100644
--- a/crates/mozart/src/commands/bump.rs
+++ b/crates/mozart/src/commands/bump.rs
@@ -109,13 +109,13 @@ pub async fn do_bump(
         // to an empty map (`getLockedRepository` would throw in PHP — Mozart degrades
         // gracefully because `bump` has nothing to bump in that case anyway).
         if composer.locker().is_locked() {
-            let lock = mozart_registry::lockfile::LockFile::read_from_file(lock_path)?;
+            let lock = mozart_core::repository::lockfile::LockFile::read_from_file(lock_path)?;
             build_locked_versions_from_lock(&lock)
         } else {
             IndexMap::new()
         }
     } else if composer.locker().is_locked() {
-        let lock = mozart_registry::lockfile::LockFile::read_from_file(lock_path)?;
+        let lock = mozart_core::repository::lockfile::LockFile::read_from_file(lock_path)?;
         if !lock.is_fresh(&contents) {
             console_writeln_error!(
                 io,
@@ -282,9 +282,10 @@ fn update_file_cleanly(
 /// successful in-place edit so the lockfile stays "fresh" for the next install.
 fn update_lock_hash(lock_path: &Path, composer_json_path: &Path) -> anyhow::Result<()> {
     let new_composer_json_content = std::fs::read_to_string(composer_json_path)?;
-    let new_hash =
-        mozart_registry::lockfile::LockFile::compute_content_hash(&new_composer_json_content)?;
-    let mut lock = mozart_registry::lockfile::LockFile::read_from_file(lock_path)?;
+    let new_hash = mozart_core::repository::lockfile::LockFile::compute_content_hash(
+        &new_composer_json_content,
+    )?;
+    let mut lock = mozart_core::repository::lockfile::LockFile::read_from_file(lock_path)?;
     lock.content_hash = new_hash;
     lock.write_to_file(lock_path)?;
     Ok(())
@@ -304,7 +305,7 @@ fn is_writable(path: &Path) -> bool {
 /// Build a map of lowercase package names to (pretty_version, version_normalized)
 /// from a parsed `composer.lock`.
 fn build_locked_versions_from_lock(
-    lock: &mozart_registry::lockfile::LockFile,
+    lock: &mozart_core::repository::lockfile::LockFile,
 ) -> IndexMap<String, (String, Option<String>)> {
     let mut map: IndexMap<String, (String, Option<String>)> = IndexMap::new();
     let all_packages = lock
@@ -352,7 +353,7 @@ fn strip_inline_constraint(arg: &str) -> &str {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use mozart_registry::lockfile::{LockFile, LockedPackage};
+    use mozart_core::repository::lockfile::{LockFile, LockedPackage};
     use tempfile::tempdir;
 
     fn minimal_lock(packages: Vec<LockedPackage>, packages_dev: Vec<LockedPackage>) -> LockFile {
diff --git a/crates/mozart/src/commands/check_platform_reqs.rs b/crates/mozart/src/commands/check_platform_reqs.rs
index 1a10882..31cdb35 100644
--- a/crates/mozart/src/commands/check_platform_reqs.rs
+++ b/crates/mozart/src/commands/check_platform_reqs.rs
@@ -89,12 +89,13 @@ pub async fn execute(
         load_lock(&lock_path, args.no_dev, &mut installed_repo, &mut requires)?;
     } else {
         let installed_packages_present = installed_path.exists()
-            && !mozart_registry::installed::InstalledPackages::read(&vendor_dir)?
+            && !mozart_core::repository::installed::InstalledPackages::read(&vendor_dir)?
                 .packages
                 .is_empty();
 
         if installed_packages_present {
-            let installed = mozart_registry::installed::InstalledPackages::read(&vendor_dir)?;
+            let installed =
+                mozart_core::repository::installed::InstalledPackages::read(&vendor_dir)?;
             console_writeln_error!(
                 console,
                 "<info>Checking {}platform requirements for packages in the vendor dir</info>",
@@ -252,9 +253,10 @@ fn load_lock(
     repo: &mut InstalledRepoLite,
     requires: &mut BTreeMap<String, Vec<Link>>,
 ) -> anyhow::Result<()> {
-    let lock = mozart_registry::lockfile::LockFile::read_from_file(lock_path)?;
+    let lock = mozart_core::repository::lockfile::LockFile::read_from_file(lock_path)?;
 
-    let mut all: Vec<&mozart_registry::lockfile::LockedPackage> = lock.packages.iter().collect();
+    let mut all: Vec<&mozart_core::repository::lockfile::LockedPackage> =
+        lock.packages.iter().collect();
     if !no_dev && let Some(ref pkgs_dev) = lock.packages_dev {
         all.extend(pkgs_dev.iter());
     }
@@ -277,7 +279,7 @@ fn load_lock(
 }
 
 fn load_installed(
-    installed: &mozart_registry::installed::InstalledPackages,
+    installed: &mozart_core::repository::installed::InstalledPackages,
     no_dev: bool,
     repo: &mut InstalledRepoLite,
     requires: &mut BTreeMap<String, Vec<Link>>,
diff --git a/crates/mozart/src/commands/clear_cache.rs b/crates/mozart/src/commands/clear_cache.rs
index 9ee27ed..6a601da 100644
--- a/crates/mozart/src/commands/clear_cache.rs
+++ b/crates/mozart/src/commands/clear_cache.rs
@@ -4,7 +4,7 @@ use crate::composer::Composer;
 use clap::Args;
 use mozart_core::console_writeln_error;
 use mozart_core::factory::create_config;
-use mozart_registry::cache::Cache;
+use mozart_core::repository::cache::Cache;
 
 #[derive(Args)]
 pub struct ClearCacheArgs {
diff --git a/crates/mozart/src/commands/create_project.rs b/crates/mozart/src/commands/create_project.rs
index ff9776d..2b2fbe1 100644
--- a/crates/mozart/src/commands/create_project.rs
+++ b/crates/mozart/src/commands/create_project.rs
@@ -3,12 +3,12 @@ use indexmap::IndexMap;
 use mozart_core::console::Console;
 use mozart_core::console_format;
 use mozart_core::package::{self, Stability};
+use mozart_core::repository::downloader;
+use mozart_core::repository::lockfile;
+use mozart_core::repository::packagist;
+use mozart_core::repository::resolver::{self, PlatformConfig, ResolveRequest};
+use mozart_core::repository::version;
 use mozart_core::validation;
-use mozart_registry::downloader;
-use mozart_registry::lockfile;
-use mozart_registry::packagist;
-use mozart_registry::resolver::{self, PlatformConfig, ResolveRequest};
-use mozart_registry::version;
 use std::path::{Path, PathBuf};
 
 #[derive(Args)]
@@ -498,8 +498,8 @@ async fn install_project(
         .and_then(|v| v.as_bool())
         .unwrap_or(false);
 
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repo_cache = mozart_registry::cache::Cache::repo(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repo_cache = mozart_core::repository::cache::Cache::repo(&cache_config);
 
     let request = ResolveRequest {
         root_name: raw.name.clone(),
@@ -515,7 +515,7 @@ async fn install_project(
         ignore_platform_reqs: args.ignore_platform_reqs,
         ignore_platform_req_list: args.ignore_platform_req.clone(),
         repositories: std::sync::Arc::new(
-            mozart_registry::repository::RepositorySet::with_packagist(repo_cache.clone()),
+            mozart_core::repository::repository::RepositorySet::with_packagist(repo_cache.clone()),
         ),
         temporary_constraints: IndexMap::new(),
         raw_repositories: raw.repositories.clone(),
@@ -559,7 +559,7 @@ async fn install_project(
         composer_json: raw.clone(),
         include_dev: dev_mode,
         repositories: std::sync::Arc::new(
-            mozart_registry::repository::RepositorySet::with_packagist(repo_cache.clone()),
+            mozart_core::repository::repository::RepositorySet::with_packagist(repo_cache.clone()),
         ),
         previous_lock: None,
         lock_pinned_names: indexmap::IndexSet::new(),
@@ -611,9 +611,10 @@ async fn install_project(
         .and_then(|v| v.as_bool())
         .unwrap_or(false);
 
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let files_cache = mozart_registry::cache::Cache::files(&cache_config);
-    let mut executor = mozart_registry::installer_executor::FilesystemExecutor::new(files_cache);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let files_cache = mozart_core::repository::cache::Cache::files(&cache_config);
+    let mut executor =
+        mozart_core::repository::installer_executor::FilesystemExecutor::new(files_cache);
     super::install::install_from_lock(
         &new_lock,
         &target_dir,
@@ -726,9 +727,9 @@ async fn install_root_package(
     let (_, minimum_stability) = resolve_stability(stability, package_version.as_deref())?;
 
     // --- Find the best candidate matching constraint + stability ---
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repo_cache = mozart_registry::cache::Cache::repo(&cache_config);
-    let files_cache = mozart_registry::cache::Cache::files(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repo_cache = mozart_core::repository::cache::Cache::repo(&cache_config);
+    let files_cache = mozart_core::repository::cache::Cache::files(&cache_config);
 
     let versions = packagist::fetch_package_versions(&name, &repo_cache).await?;
 
diff --git a/crates/mozart/src/commands/dependency.rs b/crates/mozart/src/commands/dependency.rs
index f4e7430..0bdd3da 100644
--- a/crates/mozart/src/commands/dependency.rs
+++ b/crates/mozart/src/commands/dependency.rs
@@ -258,7 +258,7 @@ fn load_from_lockfile(lock_path: &Path) -> Result<Vec<PackageInfo>> {
     if !lock_path.exists() {
         anyhow::bail!("composer.lock not found — run `mozart install` first or omit --locked");
     }
-    let lock = mozart_registry::lockfile::LockFile::read_from_file(lock_path)?;
+    let lock = mozart_core::repository::lockfile::LockFile::read_from_file(lock_path)?;
 
     let mut packages: Vec<PackageInfo> = Vec::new();
 
@@ -291,7 +291,7 @@ fn load_from_lockfile(lock_path: &Path) -> Result<Vec<PackageInfo>> {
 
 fn load_from_installed(working_dir: &Path) -> Result<Vec<PackageInfo>> {
     let vendor_dir = working_dir.join("vendor");
-    let installed = mozart_registry::installed::InstalledPackages::read(&vendor_dir)?;
+    let installed = mozart_core::repository::installed::InstalledPackages::read(&vendor_dir)?;
 
     let packages = installed
         .packages
diff --git a/crates/mozart/src/commands/dump_autoload.rs b/crates/mozart/src/commands/dump_autoload.rs
index 7557d37..f8222bb 100644
--- a/crates/mozart/src/commands/dump_autoload.rs
+++ b/crates/mozart/src/commands/dump_autoload.rs
@@ -1,6 +1,6 @@
 use crate::composer::Composer;
 use clap::Args;
-use mozart_autoload::AutoloadGeneratorExt;
+use mozart_core::autoload::AutoloadGeneratorExt;
 use mozart_core::composer::AutoloadDumpOptions;
 use mozart_core::console_writeln;
 
diff --git a/crates/mozart/src/commands/fund.rs b/crates/mozart/src/commands/fund.rs
index 90a8418..792edd6 100644
--- a/crates/mozart/src/commands/fund.rs
+++ b/crates/mozart/src/commands/fund.rs
@@ -4,9 +4,9 @@ use mozart_core::console::{Console, hyperlink};
 use mozart_core::console_format;
 use mozart_core::console_writeln;
 use mozart_core::exit_code;
-use mozart_registry::cache::{Cache, build_cache_config};
-use mozart_registry::installed::InstalledPackages;
-use mozart_registry::repository::{PackageQuery, RepositorySet};
+use mozart_core::repository::cache::{Cache, build_cache_config};
+use mozart_core::repository::installed::InstalledPackages;
+use mozart_core::repository::repository::{PackageQuery, RepositorySet};
 use serde::Serialize;
 use std::collections::{BTreeMap, BTreeSet};
 
diff --git a/crates/mozart/src/commands/init.rs b/crates/mozart/src/commands/init.rs
index 5d6d501..90a5806 100644
--- a/crates/mozart/src/commands/init.rs
+++ b/crates/mozart/src/commands/init.rs
@@ -6,8 +6,8 @@ use mozart_core::console_format;
 use mozart_core::package::{
     self, RawAuthor, RawAutoload, RawPackageData, RawRepository, Stability,
 };
+use mozart_core::repository::{packagist, version};
 use mozart_core::validation;
-use mozart_registry::{packagist, version};
 use std::collections::BTreeMap;
 use std::io::{BufRead, Write};
 use std::path::Path;
@@ -66,8 +66,8 @@ pub async fn execute(
     cli: &super::Cli,
     console: &console::Console,
 ) -> anyhow::Result<()> {
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repo_cache = mozart_registry::cache::Cache::repo(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repo_cache = mozart_core::repository::cache::Cache::repo(&cache_config);
 
     let working_dir = cli.working_dir()?;
 
@@ -235,7 +235,7 @@ async fn build_interactive(
     args: &InitArgs,
     console: &console::Console,
     working_dir: &Path,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
 ) -> anyhow::Result<RawPackageData> {
     console.info("");
     console.info(&format!(
@@ -487,7 +487,7 @@ async fn interactive_search_packages(
     label: &str,
     already_required: &BTreeMap<String, String>,
     preferred_stability: Stability,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     console: &console::Console,
 ) -> anyhow::Result<BTreeMap<String, String>> {
     let stdin = std::io::stdin();
diff --git a/crates/mozart/src/commands/install.rs b/crates/mozart/src/commands/install.rs
index 64af756..59d400b 100644
--- a/crates/mozart/src/commands/install.rs
+++ b/crates/mozart/src/commands/install.rs
@@ -2,14 +2,14 @@ use clap::Args;
 use indexmap::IndexSet;
 use mozart_core::console;
 use mozart_core::console_format;
-use mozart_registry::installed;
-use mozart_registry::installer_executor::{
+use mozart_core::repository::installed;
+use mozart_core::repository::installer_executor::{
     Action, ExecuteContext, FilesystemExecutor, InstallerExecutor, PackageOperation,
     compute_operations, compute_stale_installed_aliases, format_full_pretty_version,
     format_full_pretty_version_for_installed, format_update_pretty_versions,
     locked_to_installed_entry, previously_installed_alias_versions,
 };
-use mozart_registry::lockfile;
+use mozart_core::repository::lockfile;
 use std::collections::BTreeMap;
 use std::path::Path;
 
@@ -815,7 +815,7 @@ pub async fn install_from_lock(
             let suffix = lock.content_hash.clone();
 
             let _result =
-                mozart_autoload::autoload::generate(&mozart_autoload::autoload::AutoloadConfig {
+                mozart_core::autoload::generate(&mozart_core::autoload::AutoloadConfig {
                     project_dir: working_dir.to_path_buf(),
                     vendor_dir: vendor_dir.to_path_buf(),
                     dev_mode,
@@ -826,7 +826,7 @@ pub async fn install_from_lock(
                     apcu_prefix: config.apcu_autoloader_prefix.clone(),
                     strict_psr: false,
                     strict_ambiguous: false,
-                    platform_check: mozart_autoload::autoload::PlatformCheckMode::Full,
+                    platform_check: mozart_core::autoload::PlatformCheckMode::Full,
                     ignore_platform_reqs: config.ignore_platform_reqs,
                 })?;
         }
@@ -835,19 +835,21 @@ pub async fn install_from_lock(
     Ok(())
 }
 
-/// CLI entry point. Builds production [`mozart_registry::repository::RepositorySet`]
+/// CLI entry point. Builds production [`mozart_core::repository::repository::RepositorySet`]
 /// (Packagist) and [`FilesystemExecutor`] from `cli`, then dispatches to [`run`].
 pub async fn execute(
     args: &InstallArgs,
     cli: &super::Cli,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repositories =
-        std::sync::Arc::new(mozart_registry::repository::RepositorySet::with_packagist(
-            mozart_registry::cache::Cache::repo(&cache_config),
-        ));
-    let mut executor = FilesystemExecutor::new(mozart_registry::cache::Cache::files(&cache_config));
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repositories = std::sync::Arc::new(
+        mozart_core::repository::repository::RepositorySet::with_packagist(
+            mozart_core::repository::cache::Cache::repo(&cache_config),
+        ),
+    );
+    let mut executor =
+        FilesystemExecutor::new(mozart_core::repository::cache::Cache::files(&cache_config));
     let working_dir = cli.working_dir()?;
     run(
         &working_dir,
@@ -875,7 +877,7 @@ pub async fn run(
     path_repo_base_override: Option<&Path>,
     args: &InstallArgs,
     console: &mozart_core::console::Console,
-    repositories: std::sync::Arc<mozart_registry::repository::RepositorySet>,
+    repositories: std::sync::Arc<mozart_core::repository::repository::RepositorySet>,
     executor: &mut dyn InstallerExecutor,
 ) -> anyhow::Result<()> {
     // Step 2: Validate arguments — order matches Composer's InstallCommand::execute (80–101):
diff --git a/crates/mozart/src/commands/licenses.rs b/crates/mozart/src/commands/licenses.rs
index 671ce2a..344a5fa 100644
--- a/crates/mozart/src/commands/licenses.rs
+++ b/crates/mozart/src/commands/licenses.rs
@@ -144,7 +144,7 @@ fn load_installed_entries(
     no_dev: bool,
 ) -> anyhow::Result<Vec<LicenseEntry>> {
     let vendor_dir = working_dir.join("vendor");
-    let installed = mozart_registry::installed::InstalledPackages::read(&vendor_dir)?;
+    let installed = mozart_core::repository::installed::InstalledPackages::read(&vendor_dir)?;
 
     let entries: Vec<LicenseEntry> = installed.packages.iter().map(installed_to_entry).collect();
 
@@ -179,7 +179,7 @@ fn load_locked_entries(
             "Valid composer.json and composer.lock files are required to run this command with --locked"
         );
     }
-    let lock = mozart_registry::lockfile::LockFile::read_from_file(&lock_path)?;
+    let lock = mozart_core::repository::lockfile::LockFile::read_from_file(&lock_path)?;
 
     // Mirrors `Locker::getLockedRepository(!$noDev)`: the prod-only call
     // returns just `packages`, the dev-included call returns the union.
@@ -190,7 +190,9 @@ fn load_locked_entries(
     Ok(entries)
 }
 
-fn installed_to_entry(pkg: &mozart_registry::installed::InstalledPackageEntry) -> LicenseEntry {
+fn installed_to_entry(
+    pkg: &mozart_core::repository::installed::InstalledPackageEntry,
+) -> LicenseEntry {
     let licenses = pkg
         .extra_fields
         .get("license")
@@ -240,7 +242,7 @@ fn installed_to_entry(pkg: &mozart_registry::installed::InstalledPackageEntry) -
     }
 }
 
-fn locked_to_entry(pkg: &mozart_registry::lockfile::LockedPackage) -> LicenseEntry {
+fn locked_to_entry(pkg: &mozart_core::repository::lockfile::LockedPackage) -> LicenseEntry {
     let support_source = pkg
         .support
         .as_ref()
@@ -537,7 +539,7 @@ mod tests {
 
     #[test]
     fn installed_to_entry_extracts_require_and_license() {
-        use mozart_registry::installed::InstalledPackageEntry;
+        use mozart_core::repository::installed::InstalledPackageEntry;
         let mut extra = BTreeMap::new();
         extra.insert("license".to_string(), serde_json::json!(["MIT"]));
         extra.insert(
@@ -565,7 +567,7 @@ mod tests {
 
     #[test]
     fn installed_to_entry_pulls_support_source_and_source_url() {
-        use mozart_registry::installed::InstalledPackageEntry;
+        use mozart_core::repository::installed::InstalledPackageEntry;
         let pkg = InstalledPackageEntry {
             name: "vendor/pkg".to_string(),
             version: "1.0.0".to_string(),
@@ -608,8 +610,8 @@ mod tests {
         )
         .unwrap();
 
-        let mut installed = mozart_registry::installed::InstalledPackages::new();
-        installed.upsert(mozart_registry::installed::InstalledPackageEntry {
+        let mut installed = mozart_core::repository::installed::InstalledPackages::new();
+        installed.upsert(mozart_core::repository::installed::InstalledPackageEntry {
             name: "a/a".to_string(),
             version: "1.0.0".to_string(),
             version_normalized: None,
@@ -623,7 +625,7 @@ mod tests {
             support: None,
             extra_fields: BTreeMap::new(),
         });
-        installed.upsert(mozart_registry::installed::InstalledPackageEntry {
+        installed.upsert(mozart_core::repository::installed::InstalledPackageEntry {
             name: "b/b".to_string(),
             version: "1.0.0".to_string(),
             version_normalized: None,
@@ -653,7 +655,7 @@ mod tests {
 
     #[test]
     fn locked_no_dev_drops_packages_dev() {
-        use mozart_registry::lockfile::{LockFile, LockedPackage};
+        use mozart_core::repository::lockfile::{LockFile, LockedPackage};
         let dir = tempfile::tempdir().unwrap();
         let working_dir = dir.path();
         std::fs::write(
diff --git a/crates/mozart/src/commands/reinstall.rs b/crates/mozart/src/commands/reinstall.rs
index dc99a91..52dfd52 100644
--- a/crates/mozart/src/commands/reinstall.rs
+++ b/crates/mozart/src/commands/reinstall.rs
@@ -1,6 +1,6 @@
 use crate::composer::Composer;
 use clap::Args;
-use mozart_autoload::AutoloadGeneratorExt;
+use mozart_core::autoload::AutoloadGeneratorExt;
 use mozart_core::composer::{AutoloadDumpOptions, LocalPackage};
 use mozart_core::console_format;
 use mozart_core::validation::package_name_to_regexp;
@@ -138,8 +138,8 @@ pub async fn execute(
     // `mozart-registry::installer_executor` exposes the same shape, we
     // remove the install dir and re-download in place using each package's
     // recorded `dist` info.
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let files_cache = mozart_registry::cache::Cache::files(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let files_cache = mozart_core::repository::cache::Cache::files(&cache_config);
     let installation_manager = composer.installation_manager();
 
     for package in &packages_to_reinstall {
@@ -166,12 +166,12 @@ pub async fn execute(
             std::fs::remove_dir_all(&install_path)?;
         }
 
-        let mut progress = mozart_registry::downloader::DownloadProgress::new(
+        let mut progress = mozart_core::repository::downloader::DownloadProgress::new(
             !args.no_progress,
             format!("{} ({})", package.pretty_name(), package.pretty_version()),
         );
 
-        mozart_registry::downloader::install_package(
+        mozart_core::repository::downloader::install_package(
             &dist.url,
             &dist.kind,
             dist.shasum.as_deref(),
diff --git a/crates/mozart/src/commands/remove.rs b/crates/mozart/src/commands/remove.rs
index d4d727f..c2d4d47 100644
--- a/crates/mozart/src/commands/remove.rs
+++ b/crates/mozart/src/commands/remove.rs
@@ -3,9 +3,9 @@ use indexmap::{IndexMap, IndexSet};
 use mozart_core::console_format;
 use mozart_core::console_writeln;
 use mozart_core::package;
-use mozart_registry::installed;
-use mozart_registry::lockfile;
-use mozart_registry::resolver::{self, PlatformConfig, ResolveRequest};
+use mozart_core::repository::installed;
+use mozart_core::repository::lockfile;
+use mozart_core::repository::resolver::{self, PlatformConfig, ResolveRequest};
 
 #[derive(Args)]
 pub struct RemoveArgs {
@@ -102,8 +102,8 @@ pub async fn execute(
     cli: &super::Cli,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repo_cache = mozart_registry::cache::Cache::repo(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repo_cache = mozart_core::repository::cache::Cache::repo(&cache_config);
 
     if args.packages.is_empty() && !args.unused {
         anyhow::bail!("Not enough arguments (missing: \"packages\").");
@@ -242,7 +242,7 @@ pub async fn execute(
             ignore_platform_reqs: args.ignore_platform_reqs,
             ignore_platform_req_list: args.ignore_platform_req.clone(),
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(repo_cache.clone()),
+                mozart_core::repository::repository::RepositorySet::with_packagist(repo_cache.clone()),
             ),
             temporary_constraints: IndexMap::new(),
             raw_repositories: composer.repositories.clone(),
@@ -344,7 +344,7 @@ pub async fn execute(
             composer_json: composer.clone(),
             include_dev: dev_mode,
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(repo_cache.clone()),
+                mozart_core::repository::repository::RepositorySet::with_packagist(repo_cache.clone()),
             ),
             previous_lock: old_lock.clone(),
             lock_pinned_names: IndexSet::new(),
@@ -430,10 +430,10 @@ pub async fn execute(
         }
 
         if !args.no_install && !args.dry_run {
-            let cache_config = mozart_registry::cache::build_cache_config(no_cache);
-            let files_cache = mozart_registry::cache::Cache::files(&cache_config);
+            let cache_config = mozart_core::repository::cache::build_cache_config(no_cache);
+            let files_cache = mozart_core::repository::cache::Cache::files(&cache_config);
             let mut executor =
-                mozart_registry::installer_executor::FilesystemExecutor::new(files_cache);
+                mozart_core::repository::installer_executor::FilesystemExecutor::new(files_cache);
             super::install::install_from_lock(
                 &new_lock,
                 &working_dir,
@@ -499,7 +499,7 @@ async fn remove_unused(
     composer: &package::RawPackageData,
     working_dir: &std::path::Path,
     args: &RemoveArgs,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     no_cache: bool,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
@@ -546,7 +546,7 @@ async fn remove_unused(
         ignore_platform_reqs: args.ignore_platform_reqs,
         ignore_platform_req_list: args.ignore_platform_req.clone(),
         repositories: std::sync::Arc::new(
-            mozart_registry::repository::RepositorySet::with_packagist(repo_cache.clone()),
+            mozart_core::repository::repository::RepositorySet::with_packagist(repo_cache.clone()),
         ),
         temporary_constraints: IndexMap::new(),
         raw_repositories: composer.repositories.clone(),
@@ -625,7 +625,7 @@ async fn remove_unused(
         composer_json: composer.clone(),
         include_dev: dev_mode,
         repositories: std::sync::Arc::new(
-            mozart_registry::repository::RepositorySet::with_packagist(repo_cache.clone()),
+            mozart_core::repository::repository::RepositorySet::with_packagist(repo_cache.clone()),
         ),
         previous_lock: Some(old_lock.clone()),
         lock_pinned_names: IndexSet::new(),
@@ -637,10 +637,10 @@ async fn remove_unused(
 
     if !args.no_install {
         let vendor_dir = working_dir.join("vendor");
-        let cache_config = mozart_registry::cache::build_cache_config(no_cache);
-        let files_cache = mozart_registry::cache::Cache::files(&cache_config);
+        let cache_config = mozart_core::repository::cache::build_cache_config(no_cache);
+        let files_cache = mozart_core::repository::cache::Cache::files(&cache_config);
         let mut executor =
-            mozart_registry::installer_executor::FilesystemExecutor::new(files_cache);
+            mozart_core::repository::installer_executor::FilesystemExecutor::new(files_cache);
         super::install::install_from_lock(
             &new_lock,
             working_dir,
@@ -672,7 +672,7 @@ async fn remove_unused(
 mod tests {
     use super::*;
     use mozart_core::package::RawPackageData;
-    use mozart_registry::lockfile;
+    use mozart_core::repository::lockfile;
     use std::collections::BTreeMap;
 
     fn make_locked_package(name: &str, version: &str) -> lockfile::LockedPackage {
@@ -920,8 +920,8 @@ mod tests {
     #[ignore]
     async fn test_remove_full_e2e() {
         use indexmap::{IndexMap, IndexSet};
-        use mozart_registry::lockfile::{LockFileGenerationRequest, generate_lock_file};
-        use mozart_registry::resolver::{ResolveRequest, resolve};
+        use mozart_core::repository::lockfile::{LockFileGenerationRequest, generate_lock_file};
+        use mozart_core::repository::resolver::{ResolveRequest, resolve};
         use tempfile::tempdir;
 
         let dir = tempdir().unwrap();
@@ -944,12 +944,12 @@ mod tests {
             stability_flags: IndexMap::new(),
             prefer_stable: true,
             prefer_lowest: false,
-            platform: mozart_registry::resolver::PlatformConfig::new(),
+            platform: mozart_core::repository::resolver::PlatformConfig::new(),
             ignore_platform_reqs: false,
             ignore_platform_req_list: vec![],
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
@@ -976,8 +976,8 @@ mod tests {
             composer_json: composer.clone(),
             include_dev: false,
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
@@ -1005,12 +1005,12 @@ mod tests {
             stability_flags: IndexMap::new(),
             prefer_stable: true,
             prefer_lowest: false,
-            platform: mozart_registry::resolver::PlatformConfig::new(),
+            platform: mozart_core::repository::resolver::PlatformConfig::new(),
             ignore_platform_reqs: false,
             ignore_platform_req_list: vec![],
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
@@ -1039,8 +1039,8 @@ mod tests {
             composer_json: composer,
             include_dev: false,
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
diff --git a/crates/mozart/src/commands/require.rs b/crates/mozart/src/commands/require.rs
index 3ccba96..9ec4195 100644
--- a/crates/mozart/src/commands/require.rs
+++ b/crates/mozart/src/commands/require.rs
@@ -3,12 +3,12 @@ use indexmap::{IndexMap, IndexSet};
 use mozart_core::console_format;
 use mozart_core::console_writeln;
 use mozart_core::package::{self, RawPackageData, Stability};
+use mozart_core::repository::lockfile;
+use mozart_core::repository::packagist;
+use mozart_core::repository::resolver::{self, PlatformConfig, ResolveRequest};
+use mozart_core::repository::version;
+use mozart_core::repository::version_selector::VersionSelector;
 use mozart_core::validation;
-use mozart_registry::lockfile;
-use mozart_registry::packagist;
-use mozart_registry::resolver::{self, PlatformConfig, ResolveRequest};
-use mozart_registry::version;
-use mozart_registry::version_selector::VersionSelector;
 use std::io::{BufRead, IsTerminal, Write};
 use std::path::{Path, PathBuf};
 
@@ -270,8 +270,8 @@ async fn do_update(
 ) -> anyhow::Result<()> {
     let working_dir = cli.working_dir()?;
     let vendor_dir = working_dir.join("vendor");
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repo_cache = mozart_registry::cache::Cache::repo(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repo_cache = mozart_core::repository::cache::Cache::repo(&cache_config);
 
     let dev_mode = !args.update_no_dev;
 
@@ -322,7 +322,7 @@ async fn do_update(
         ignore_platform_reqs: args.ignore_platform_reqs,
         ignore_platform_req_list: args.ignore_platform_req.clone(),
         repositories: std::sync::Arc::new(
-            mozart_registry::repository::RepositorySet::with_packagist(repo_cache.clone()),
+            mozart_core::repository::repository::RepositorySet::with_packagist(repo_cache.clone()),
         ),
         temporary_constraints: IndexMap::new(),
         raw_repositories: raw.repositories.clone(),
@@ -444,7 +444,7 @@ async fn do_update(
         composer_json: raw.clone(),
         include_dev: dev_mode,
         repositories: std::sync::Arc::new(
-            mozart_registry::repository::RepositorySet::with_packagist(repo_cache.clone()),
+            mozart_core::repository::repository::RepositorySet::with_packagist(repo_cache.clone()),
         ),
         previous_lock: old_lock.clone(),
         lock_pinned_names: IndexSet::new(),
@@ -548,11 +548,11 @@ async fn do_update(
             .and_then(|v| v.as_bool())
             .unwrap_or(false);
 
-        let files_cache = mozart_registry::cache::Cache::files(
-            &mozart_registry::cache::build_cache_config(cli.no_cache),
+        let files_cache = mozart_core::repository::cache::Cache::files(
+            &mozart_core::repository::cache::build_cache_config(cli.no_cache),
         );
         let mut executor =
-            mozart_registry::installer_executor::FilesystemExecutor::new(files_cache);
+            mozart_core::repository::installer_executor::FilesystemExecutor::new(files_cache);
         super::install::install_from_lock(
             &new_lock,
             &working_dir,
@@ -590,7 +590,7 @@ async fn interactive_search_packages(
     already_required: &indexmap::IndexSet<String>,
     preferred_stability: Stability,
     fixed: bool,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<Vec<String>> {
     let stdin = std::io::stdin();
@@ -784,8 +784,8 @@ pub async fn execute(
     cli: &super::Cli,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repo_cache = mozart_registry::cache::Cache::repo(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repo_cache = mozart_core::repository::cache::Cache::repo(&cache_config);
 
     // --- Deprecated flag warnings ---
     // Mirrors Composer\Command\RequireCommand::execute() L134-136.
@@ -1316,7 +1316,7 @@ mod tests {
     async fn test_require_full_e2e() {
         use indexmap::IndexSet;
         use mozart_core::package::RawPackageData;
-        use mozart_registry::lockfile::{LockFileGenerationRequest, generate_lock_file};
+        use mozart_core::repository::lockfile::{LockFileGenerationRequest, generate_lock_file};
 
         let composer_json_content = r#"{"name": "test/project", "require": {"psr/log": "^3.0"}}"#;
         let composer_json: RawPackageData = serde_json::from_str(composer_json_content).unwrap();
@@ -1335,8 +1335,8 @@ mod tests {
             ignore_platform_reqs: false,
             ignore_platform_req_list: vec![],
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
@@ -1367,8 +1367,8 @@ mod tests {
             composer_json,
             include_dev: false,
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
@@ -1416,8 +1416,8 @@ mod tests {
             ignore_platform_reqs: false,
             ignore_platform_req_list: vec![],
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
@@ -1445,8 +1445,8 @@ mod tests {
             composer_json: raw,
             include_dev: false,
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
diff --git a/crates/mozart/src/commands/search.rs b/crates/mozart/src/commands/search.rs
index 14d50dd..a5ab04a 100644
--- a/crates/mozart/src/commands/search.rs
+++ b/crates/mozart/src/commands/search.rs
@@ -2,8 +2,8 @@ use clap::Args;
 use mozart_core::console::{Console, hyperlink};
 use mozart_core::console_format;
 use mozart_core::console_writeln;
-use mozart_registry::packagist::SearchResult;
-use mozart_registry::repository::{RepositorySet, SearchMode};
+use mozart_core::repository::packagist::SearchResult;
+use mozart_core::repository::repository::{RepositorySet, SearchMode};
 use serde::Serialize;
 
 /// JSON output structure matching Composer's search result schema.
@@ -111,8 +111,8 @@ pub async fn execute(args: &SearchArgs, cli: &super::Cli, console: &Console) ->
     // 5. Build the repository set. Configured remote repositories from
     //    `composer.json` are not yet wired up; this is a known divergence
     //    from Composer's full `CompositeRepository`.
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repo_cache = mozart_registry::cache::Cache::repo(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repo_cache = mozart_core::repository::cache::Cache::repo(&cache_config);
     let repos = RepositorySet::with_packagist(repo_cache);
 
     // 6. Dispatch.
@@ -199,7 +199,7 @@ mod tests {
 
     #[test]
     fn test_parse_search_response() {
-        use mozart_registry::packagist::SearchResponse;
+        use mozart_core::repository::packagist::SearchResponse;
 
         let json = r#"{
             "results": [
@@ -245,7 +245,7 @@ mod tests {
 
     #[test]
     fn test_parse_search_response_with_abandoned() {
-        use mozart_registry::packagist::SearchResponse;
+        use mozart_core::repository::packagist::SearchResponse;
 
         let json = r#"{
             "results": [
@@ -288,7 +288,7 @@ mod tests {
 
     #[test]
     fn test_parse_search_response_with_next() {
-        use mozart_registry::packagist::SearchResponse;
+        use mozart_core::repository::packagist::SearchResponse;
 
         let json = r#"{
             "results": [],
diff --git a/crates/mozart/src/commands/show.rs b/crates/mozart/src/commands/show.rs
index f0b82b3..8876694 100644
--- a/crates/mozart/src/commands/show.rs
+++ b/crates/mozart/src/commands/show.rs
@@ -110,8 +110,8 @@ pub async fn execute(
     cli: &super::Cli,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repo_cache = mozart_registry::cache::Cache::repo(&cache_config);
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repo_cache = mozart_core::repository::cache::Cache::repo(&cache_config);
 
     // A9: --installed deprecation warning (mirrors Composer 143-145)
     if args.installed && !args.self_info {
@@ -296,12 +296,13 @@ async fn fetch_latest_for_package(
     name: &str,
     current_normalized: &str,
     args: &ShowArgs,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
 ) -> anyhow::Result<LatestInfo> {
     use mozart_core::package::Stability;
-    use mozart_registry::version::find_best_candidate;
+    use mozart_core::repository::version::find_best_candidate;
 
-    let versions = mozart_registry::packagist::fetch_package_versions(name, repo_cache).await?;
+    let versions =
+        mozart_core::repository::packagist::fetch_package_versions(name, repo_cache).await?;
 
     let current_major = extract_major(current_normalized);
     let current_minor = extract_minor(current_normalized);
@@ -313,7 +314,7 @@ async fn fetch_latest_for_package(
         anyhow::bail!("Cannot determine major update for dev version of {name}");
     }
 
-    let filtered: Vec<mozart_registry::packagist::PackagistVersion> = versions
+    let filtered: Vec<mozart_core::repository::packagist::PackagistVersion> = versions
         .iter()
         .filter(|v| {
             let v_norm = &v.version_normalized;
@@ -355,7 +356,7 @@ fn abandoned_info(val: &serde_json::Value) -> Option<String> {
 }
 
 fn classify_update_category(current_normalized: &str, latest_normalized: &str) -> ListUpdateKind {
-    use mozart_registry::version::compare_normalized_versions;
+    use mozart_core::repository::version::compare_normalized_versions;
     use std::cmp::Ordering;
 
     if compare_normalized_versions(latest_normalized, current_normalized) != Ordering::Greater {
@@ -400,10 +401,10 @@ fn extract_minor(version_normalized: &str) -> u64 {
 // ============================================================================
 
 async fn collect_installed_entries(
-    packages: &[&mozart_registry::installed::InstalledPackageEntry],
+    packages: &[&mozart_core::repository::installed::InstalledPackageEntry],
     args: &ShowArgs,
     direct_names: &IndexSet<String>,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
 ) -> Vec<PackageEntry> {
     let show_latest = args.latest || args.outdated;
     let mut entries = Vec::new();
@@ -435,7 +436,7 @@ async fn collect_installed_entries(
 
         if args.outdated {
             if let Some(ref li) = latest_info {
-                use mozart_registry::version::compare_normalized_versions;
+                use mozart_core::repository::version::compare_normalized_versions;
                 use std::cmp::Ordering;
                 if compare_normalized_versions(&li.version_normalized, &version_normalized)
                     != Ordering::Greater
@@ -462,10 +463,10 @@ async fn collect_installed_entries(
 }
 
 async fn collect_locked_entries(
-    packages: &[&mozart_registry::lockfile::LockedPackage],
+    packages: &[&mozart_core::repository::lockfile::LockedPackage],
     args: &ShowArgs,
     direct_names: &IndexSet<String>,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
 ) -> Vec<PackageEntry> {
     let show_latest = args.latest || args.outdated;
     let mut entries = Vec::new();
@@ -497,7 +498,7 @@ async fn collect_locked_entries(
 
         if args.outdated {
             if let Some(ref li) = latest_info {
-                use mozart_registry::version::compare_normalized_versions;
+                use mozart_core::repository::version::compare_normalized_versions;
                 use std::cmp::Ordering;
                 if compare_normalized_versions(&li.version_normalized, &version_normalized)
                     != Ordering::Greater
@@ -803,7 +804,7 @@ fn render_list_json(
 
 /// Build a `PackageDetail` from an installed package entry.
 fn installed_to_detail(
-    pkg: &mozart_registry::installed::InstalledPackageEntry,
+    pkg: &mozart_core::repository::installed::InstalledPackageEntry,
     vendor_dir: &Path,
 ) -> PackageDetail {
     let install_path = vendor_dir.join(&pkg.name);
@@ -871,7 +872,7 @@ fn installed_to_detail(
 }
 
 /// Build a `PackageDetail` from a locked package entry.
-fn locked_to_detail(pkg: &mozart_registry::lockfile::LockedPackage) -> PackageDetail {
+fn locked_to_detail(pkg: &mozart_core::repository::lockfile::LockedPackage) -> PackageDetail {
     let mut names = vec![pkg.name.clone()];
     names.extend(pkg.provide.keys().cloned());
     names.extend(pkg.replace.keys().cloned());
@@ -927,7 +928,7 @@ fn locked_to_detail(pkg: &mozart_registry::lockfile::LockedPackage) -> PackageDe
 async fn print_package_detail(
     detail: &PackageDetail,
     args: &ShowArgs,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
     if args.format == "json" {
@@ -1157,7 +1158,7 @@ fn print_links_section(
 async fn print_package_detail_json(
     detail: &PackageDetail,
     args: &ShowArgs,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
     let mut obj = serde_json::json!({
@@ -1225,11 +1226,11 @@ async fn print_package_detail_json(
 async fn execute_installed(
     args: &ShowArgs,
     working_dir: &Path,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
     let vendor_dir = working_dir.join("vendor");
-    let installed = mozart_registry::installed::InstalledPackages::read(&vendor_dir)?;
+    let installed = mozart_core::repository::installed::InstalledPackages::read(&vendor_dir)?;
 
     if installed.packages.is_empty() {
         let composer_json_path = working_dir.join("composer.json");
@@ -1343,11 +1344,11 @@ async fn execute_installed(
 }
 
 fn filter_installed_packages<'a>(
-    installed: &'a mozart_registry::installed::InstalledPackages,
+    installed: &'a mozart_core::repository::installed::InstalledPackages,
     args: &ShowArgs,
     direct_names: &IndexSet<String>,
-) -> Vec<&'a mozart_registry::installed::InstalledPackageEntry> {
-    let mut packages: Vec<&mozart_registry::installed::InstalledPackageEntry> =
+) -> Vec<&'a mozart_core::repository::installed::InstalledPackageEntry> {
+    let mut packages: Vec<&mozart_core::repository::installed::InstalledPackageEntry> =
         installed.packages.iter().collect();
 
     // --no-dev: exclude dev packages
@@ -1376,7 +1377,7 @@ fn filter_installed_packages<'a>(
 async fn execute_locked(
     args: &ShowArgs,
     working_dir: &Path,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
     let lock_path = working_dir.join("composer.lock");
@@ -1386,9 +1387,9 @@ async fn execute_locked(
         );
     }
 
-    let lock = mozart_registry::lockfile::LockFile::read_from_file(&lock_path)?;
+    let lock = mozart_core::repository::lockfile::LockFile::read_from_file(&lock_path)?;
 
-    let mut packages: Vec<&mozart_registry::lockfile::LockedPackage> =
+    let mut packages: Vec<&mozart_core::repository::lockfile::LockedPackage> =
         lock.packages.iter().collect();
 
     if let Some(ref pkgs_dev) = lock.packages_dev
@@ -1573,10 +1574,10 @@ fn show_tree(
 
     let root = mozart_core::package::read_from_file(&composer_json_path)?;
 
-    let pkg_map: IndexMap<String, &mozart_registry::lockfile::LockedPackage>;
+    let pkg_map: IndexMap<String, &mozart_core::repository::lockfile::LockedPackage>;
     let lock_storage;
     if lock_path.exists() {
-        lock_storage = mozart_registry::lockfile::LockFile::read_from_file(&lock_path)?;
+        lock_storage = mozart_core::repository::lockfile::LockFile::read_from_file(&lock_path)?;
         pkg_map = lock_storage
             .packages
             .iter()
@@ -1635,7 +1636,7 @@ fn show_tree(
 fn print_tree_node(
     pkg_name: &str,
     constraint: &str,
-    pkg_map: &IndexMap<String, &mozart_registry::lockfile::LockedPackage>,
+    pkg_map: &IndexMap<String, &mozart_core::repository::lockfile::LockedPackage>,
     prefix: &str,
     child_prefix: &str,
     visited: &mut IndexSet<String>,
@@ -1736,7 +1737,7 @@ fn show_platform(
 
     let lock_path = working_dir.join("composer.lock");
     if lock_path.exists() {
-        let lock = mozart_registry::lockfile::LockFile::read_from_file(&lock_path)?;
+        let lock = mozart_core::repository::lockfile::LockFile::read_from_file(&lock_path)?;
 
         if let Some(obj) = lock.platform.as_object() {
             for (name, version_val) in obj {
@@ -1839,7 +1840,7 @@ fn show_platform(
 async fn show_available(
     args: &ShowArgs,
     working_dir: &Path,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
     if let Some(ref pkg_name) = args.package {
@@ -1847,21 +1848,21 @@ async fn show_available(
     }
 
     let vendor_dir = working_dir.join("vendor");
-    let installed = mozart_registry::installed::InstalledPackages::read(&vendor_dir);
+    let installed = mozart_core::repository::installed::InstalledPackages::read(&vendor_dir);
 
     let installed = match installed {
         Ok(i) if !i.packages.is_empty() => i,
         _ => {
             let lock_path = working_dir.join("composer.lock");
             if lock_path.exists() {
-                let lock = mozart_registry::lockfile::LockFile::read_from_file(&lock_path)?;
+                let lock = mozart_core::repository::lockfile::LockFile::read_from_file(&lock_path)?;
                 console_writeln!(
                     console,
                     "<info>Available versions for locked packages (from Packagist):</info>",
                 );
                 console_writeln!(console, "");
 
-                let mut all_packages: Vec<&mozart_registry::lockfile::LockedPackage> =
+                let mut all_packages: Vec<&mozart_core::repository::lockfile::LockedPackage> =
                     lock.packages.iter().collect();
                 if !args.no_dev
                     && let Some(ref dev_pkgs) = lock.packages_dev
@@ -1898,7 +1899,9 @@ async fn show_available(
             if is_platform_package(&pkg.name) {
                 continue;
             }
-            match mozart_registry::packagist::fetch_package_versions(&pkg.name, repo_cache).await {
+            match mozart_core::repository::packagist::fetch_package_versions(&pkg.name, repo_cache)
+                .await
+            {
                 Ok(versions) => {
                     let version_strings: Vec<String> =
                         versions.iter().map(|v| v.version.clone()).collect();
@@ -1934,11 +1937,12 @@ async fn show_available(
 
 async fn show_available_versions(
     pkg_name: &str,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     args: &ShowArgs,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
-    let versions = mozart_registry::packagist::fetch_package_versions(pkg_name, repo_cache).await?;
+    let versions =
+        mozart_core::repository::packagist::fetch_package_versions(pkg_name, repo_cache).await?;
     if versions.is_empty() {
         console_writeln!(console, "No versions found for {pkg_name}");
         return Ok(());
@@ -1967,10 +1971,10 @@ async fn show_available_versions(
 
 async fn show_available_versions_inline(
     pkg_name: &str,
-    repo_cache: &mozart_registry::cache::Cache,
+    repo_cache: &mozart_core::repository::cache::Cache,
     console: &mozart_core::console::Console,
 ) {
-    match mozart_registry::packagist::fetch_package_versions(pkg_name, repo_cache).await {
+    match mozart_core::repository::packagist::fetch_package_versions(pkg_name, repo_cache).await {
         Ok(versions) => {
             if versions.is_empty() {
                 console_writeln!(
@@ -2020,7 +2024,9 @@ fn format_version_highlight(version: &str) -> String {
     format!("* {}", format_version(version))
 }
 
-fn get_installed_description(pkg: &mozart_registry::installed::InstalledPackageEntry) -> String {
+fn get_installed_description(
+    pkg: &mozart_core::repository::installed::InstalledPackageEntry,
+) -> String {
     pkg.extra_fields
         .get("description")
         .and_then(|v| v.as_str())
@@ -2029,7 +2035,7 @@ fn get_installed_description(pkg: &mozart_registry::installed::InstalledPackageE
 }
 
 fn get_installed_keywords_vec(
-    pkg: &mozart_registry::installed::InstalledPackageEntry,
+    pkg: &mozart_core::repository::installed::InstalledPackageEntry,
 ) -> Vec<String> {
     pkg.extra_fields
         .get("keywords")
@@ -2042,7 +2048,9 @@ fn get_installed_keywords_vec(
         .unwrap_or_default()
 }
 
-fn get_installed_licenses(pkg: &mozart_registry::installed::InstalledPackageEntry) -> Vec<String> {
+fn get_installed_licenses(
+    pkg: &mozart_core::repository::installed::InstalledPackageEntry,
+) -> Vec<String> {
     pkg.extra_fields
         .get("license")
         .and_then(|v| v.as_array())
@@ -2055,7 +2063,7 @@ fn get_installed_licenses(pkg: &mozart_registry::installed::InstalledPackageEntr
 }
 
 fn get_installed_homepage(
-    pkg: &mozart_registry::installed::InstalledPackageEntry,
+    pkg: &mozart_core::repository::installed::InstalledPackageEntry,
 ) -> Option<String> {
     pkg.extra_fields
         .get("homepage")
@@ -2064,7 +2072,7 @@ fn get_installed_homepage(
 }
 
 fn get_installed_release_date(
-    pkg: &mozart_registry::installed::InstalledPackageEntry,
+    pkg: &mozart_core::repository::installed::InstalledPackageEntry,
 ) -> Option<String> {
     pkg.extra_fields
         .get("time")
@@ -2075,7 +2083,7 @@ fn get_installed_release_date(
 /// Extract a map of `{name: constraint}` from an installed package's
 /// extra_fields for the given key (e.g. "require", "conflict", "provide").
 fn get_installed_link_map(
-    pkg: &mozart_registry::installed::InstalledPackageEntry,
+    pkg: &mozart_core::repository::installed::InstalledPackageEntry,
     key: &str,
 ) -> BTreeMap<String, String> {
     pkg.extra_fields
@@ -2091,7 +2099,7 @@ fn get_installed_link_map(
 
 /// Extract a map of `{package: reason}` from an installed package's suggest field.
 fn get_installed_suggest_map(
-    pkg: &mozart_registry::installed::InstalledPackageEntry,
+    pkg: &mozart_core::repository::installed::InstalledPackageEntry,
 ) -> BTreeMap<String, String> {
     pkg.extra_fields
         .get("suggest")
@@ -2274,7 +2282,7 @@ mod tests {
             "description".to_string(),
             serde_json::Value::String("A logging library".to_string()),
         );
-        let pkg = mozart_registry::installed::InstalledPackageEntry {
+        let pkg = mozart_core::repository::installed::InstalledPackageEntry {
             name: "monolog/monolog".to_string(),
             version: "3.0.0".to_string(),
             version_normalized: None,
@@ -2294,7 +2302,7 @@ mod tests {
     #[test]
     fn test_get_installed_description_absent() {
         use std::collections::BTreeMap;
-        let pkg = mozart_registry::installed::InstalledPackageEntry {
+        let pkg = mozart_core::repository::installed::InstalledPackageEntry {
             name: "psr/log".to_string(),
             version: "3.0.0".to_string(),
             version_normalized: None,
@@ -2319,7 +2327,7 @@ mod tests {
             "keywords".to_string(),
             serde_json::json!(["log", "psr3", "logging"]),
         );
-        let pkg = mozart_registry::installed::InstalledPackageEntry {
+        let pkg = mozart_core::repository::installed::InstalledPackageEntry {
             name: "psr/log".to_string(),
             version: "3.0.0".to_string(),
             version_normalized: None,
diff --git a/crates/mozart/src/commands/status.rs b/crates/mozart/src/commands/status.rs
index d15ffb3..f0445bf 100644
--- a/crates/mozart/src/commands/status.rs
+++ b/crates/mozart/src/commands/status.rs
@@ -5,7 +5,7 @@ use mozart_core::console::Console;
 use mozart_core::console_writeln;
 use mozart_core::console_writeln_error;
 use mozart_core::exit_code;
-use mozart_vcs::version_guesser::{VersionGuesser, VersionParser};
+use mozart_core::vcs::version_guesser::{VersionGuesser, VersionParser};
 
 #[derive(Args)]
 pub struct StatusArgs {}
diff --git a/crates/mozart/src/commands/suggests.rs b/crates/mozart/src/commands/suggests.rs
index 690b9d3..1643e94 100644
--- a/crates/mozart/src/commands/suggests.rs
+++ b/crates/mozart/src/commands/suggests.rs
@@ -62,7 +62,7 @@ pub async fn execute(
     // Iterate every package that contributes suggestions: locked/installed,
     // then root. Mirrors `$installedRepo->getPackages() + $composer->getPackage()`.
     if has_lock {
-        let lock = mozart_registry::lockfile::LockFile::read_from_file(&lock_path)?;
+        let lock = mozart_core::repository::lockfile::LockFile::read_from_file(&lock_path)?;
         for pkg in lock.packages.iter() {
             if filter.is_empty() || filter.contains(&pkg.name) {
                 reporter.add_suggestions_from_package(pkg);
@@ -79,7 +79,7 @@ pub async fn execute(
         }
     } else {
         let vendor_dir = working_dir.join("vendor");
-        let installed = mozart_registry::installed::InstalledPackages::read(&vendor_dir)?;
+        let installed = mozart_core::repository::installed::InstalledPackages::read(&vendor_dir)?;
 
         if installed.packages.is_empty() {
             let installed_json = vendor_dir.join("composer/installed.json");
@@ -148,9 +148,9 @@ fn build_installed_repo(
 
     if has_lock {
         let lock_path = working_dir.join("composer.lock");
-        let lock = mozart_registry::lockfile::LockFile::read_from_file(&lock_path)?;
+        let lock = mozart_core::repository::lockfile::LockFile::read_from_file(&lock_path)?;
 
-        let mut all_packages: Vec<&mozart_registry::lockfile::LockedPackage> =
+        let mut all_packages: Vec<&mozart_core::repository::lockfile::LockedPackage> =
             lock.packages.iter().collect();
         if !no_dev && let Some(ref pkgs_dev) = lock.packages_dev {
             all_packages.extend(pkgs_dev.iter());
@@ -179,7 +179,7 @@ fn build_installed_repo(
         }
     } else {
         let vendor_dir = working_dir.join("vendor");
-        let installed = mozart_registry::installed::InstalledPackages::read(&vendor_dir)?;
+        let installed = mozart_core::repository::installed::InstalledPackages::read(&vendor_dir)?;
 
         let dev_names: IndexSet<String> = installed
             .dev_package_names
@@ -238,8 +238,8 @@ mod tests {
     fn make_locked_package(
         name: &str,
         suggest: Option<BTreeMap<String, String>>,
-    ) -> mozart_registry::lockfile::LockedPackage {
-        mozart_registry::lockfile::LockedPackage {
+    ) -> mozart_core::repository::lockfile::LockedPackage {
+        mozart_core::repository::lockfile::LockedPackage {
             name: name.to_string(),
             version: "1.0.0".to_string(),
             version_normalized: None,
@@ -269,7 +269,7 @@ mod tests {
     fn make_installed_entry(
         name: &str,
         suggest: Option<BTreeMap<String, String>>,
-    ) -> mozart_registry::installed::InstalledPackageEntry {
+    ) -> mozart_core::repository::installed::InstalledPackageEntry {
         let mut extra_fields: BTreeMap<String, serde_json::Value> = BTreeMap::new();
         if let Some(s) = suggest {
             let map: serde_json::Map<String, serde_json::Value> = s
@@ -278,7 +278,7 @@ mod tests {
                 .collect();
             extra_fields.insert("suggest".to_string(), serde_json::Value::Object(map));
         }
-        mozart_registry::installed::InstalledPackageEntry {
+        mozart_core::repository::installed::InstalledPackageEntry {
             name: name.to_string(),
             version: "1.0.0".to_string(),
             version_normalized: None,
@@ -295,11 +295,11 @@ mod tests {
     }
 
     fn minimal_lock(
-        packages: Vec<mozart_registry::lockfile::LockedPackage>,
-        packages_dev: Option<Vec<mozart_registry::lockfile::LockedPackage>>,
-    ) -> mozart_registry::lockfile::LockFile {
-        mozart_registry::lockfile::LockFile {
-            readme: mozart_registry::lockfile::LockFile::default_readme(),
+        packages: Vec<mozart_core::repository::lockfile::LockedPackage>,
+        packages_dev: Option<Vec<mozart_core::repository::lockfile::LockedPackage>>,
+    ) -> mozart_core::repository::lockfile::LockFile {
+        mozart_core::repository::lockfile::LockFile {
+            readme: mozart_core::repository::lockfile::LockFile::default_readme(),
             content_hash: "abc123".to_string(),
             packages,
             packages_dev,
diff --git a/crates/mozart/src/commands/update.rs b/crates/mozart/src/commands/update.rs
index 11672fd..5498983 100644
--- a/crates/mozart/src/commands/update.rs
+++ b/crates/mozart/src/commands/update.rs
@@ -4,8 +4,8 @@ use indexmap::{IndexMap, IndexSet};
 use mozart_core::console_format;
 use mozart_core::package;
 use mozart_core::platform::is_platform_package;
-use mozart_registry::lockfile;
-use mozart_registry::resolver::{
+use mozart_core::repository::lockfile;
+use mozart_core::repository::resolver::{
     self, LockedPackageInfo, PlatformConfig, ResolveRequest, ResolvedPackage,
 };
 
@@ -559,13 +559,13 @@ pub fn collect_repo_requires(
     repositories: &[mozart_core::package::RawRepository],
 ) -> IndexMap<String, IndexSet<String>> {
     let mut out: IndexMap<String, IndexSet<String>> = IndexMap::new();
-    for ipkg in mozart_registry::inline_package::collect_inline_packages(repositories) {
+    for ipkg in mozart_core::repository::inline_package::collect_inline_packages(repositories) {
         let entry = out.entry(ipkg.name.to_lowercase()).or_default();
         for req in ipkg.version.require.keys() {
             entry.insert(req.to_lowercase());
         }
     }
-    for cpkg in mozart_registry::composer_repo::collect_composer_packages(repositories) {
+    for cpkg in mozart_core::repository::composer_repo::collect_composer_packages(repositories) {
         let entry = out.entry(cpkg.name.to_lowercase()).or_default();
         for req in cpkg.version.require.keys() {
             entry.insert(req.to_lowercase());
@@ -923,13 +923,14 @@ pub async fn execute(
     cli: &super::Cli,
     console: &mozart_core::console::Console,
 ) -> anyhow::Result<()> {
-    let cache_config = mozart_registry::cache::build_cache_config(cli.no_cache);
-    let repositories =
-        std::sync::Arc::new(mozart_registry::repository::RepositorySet::with_packagist(
-            mozart_registry::cache::Cache::repo(&cache_config),
-        ));
-    let mut executor = mozart_registry::installer_executor::FilesystemExecutor::new(
-        mozart_registry::cache::Cache::files(&cache_config),
+    let cache_config = mozart_core::repository::cache::build_cache_config(cli.no_cache);
+    let repositories = std::sync::Arc::new(
+        mozart_core::repository::repository::RepositorySet::with_packagist(
+            mozart_core::repository::cache::Cache::repo(&cache_config),
+        ),
+    );
+    let mut executor = mozart_core::repository::installer_executor::FilesystemExecutor::new(
+        mozart_core::repository::cache::Cache::files(&cache_config),
     );
     let working_dir = cli.working_dir()?;
     run(
@@ -962,8 +963,8 @@ pub async fn run(
     path_repo_base_override: Option<&std::path::Path>,
     args: &UpdateArgs,
     console: &mozart_core::console::Console,
-    repositories: std::sync::Arc<mozart_registry::repository::RepositorySet>,
-    executor: &mut dyn mozart_registry::installer_executor::InstallerExecutor,
+    repositories: std::sync::Arc<mozart_core::repository::repository::RepositorySet>,
+    executor: &mut dyn mozart_core::repository::installer_executor::InstallerExecutor,
 ) -> anyhow::Result<()> {
     // Step 2: Handle deprecated flags
     if args.dev {
@@ -1005,7 +1006,7 @@ pub async fn run(
     let path_repo_base = path_repo_base_override.unwrap_or(working_dir);
     let composer_json_expanded = {
         let mut clone = composer_json.clone();
-        clone.repositories = mozart_registry::path_repository::expand_path_repositories(
+        clone.repositories = mozart_core::repository::path_repository::expand_path_repositories(
             &clone.repositories,
             path_repo_base,
         );
@@ -2379,8 +2380,8 @@ mod tests {
     #[ignore]
     async fn test_update_full_e2e() {
         use mozart_core::package::RawPackageData;
-        use mozart_registry::lockfile::{LockFileGenerationRequest, generate_lock_file};
-        use mozart_registry::resolver::{ResolveRequest, resolve};
+        use mozart_core::repository::lockfile::{LockFileGenerationRequest, generate_lock_file};
+        use mozart_core::repository::resolver::{ResolveRequest, resolve};
 
         let composer_json_content =
             r#"{"name": "test/project", "require": {"monolog/monolog": "^3.0"}}"#;
@@ -2400,8 +2401,8 @@ mod tests {
             ignore_platform_reqs: false,
             ignore_platform_req_list: vec![],
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
@@ -2430,8 +2431,8 @@ mod tests {
             composer_json,
             include_dev: false,
             repositories: std::sync::Arc::new(
-                mozart_registry::repository::RepositorySet::with_packagist(
-                    mozart_registry::cache::Cache::new(
+                mozart_core::repository::repository::RepositorySet::with_packagist(
+                    mozart_core::repository::cache::Cache::new(
                         std::env::temp_dir().join("mozart-test-cache"),
                         false,
                     ),
diff --git a/crates/mozart/src/commands/validate.rs b/crates/mozart/src/commands/validate.rs
index 873b371..853eb2b 100644
--- a/crates/mozart/src/commands/validate.rs
+++ b/crates/mozart/src/commands/validate.rs
@@ -337,7 +337,7 @@ fn check_lock_freshness(
         return;
     }
 
-    match mozart_registry::lockfile::LockFile::read_from_file(&lock_path) {
+    match mozart_core::repository::lockfile::LockFile::read_from_file(&lock_path) {
         Ok(lock) => {
             if !lock.is_fresh(composer_json_content) {
                 lock_errors.push(
@@ -578,7 +578,7 @@ mod tests {
 
     #[test]
     fn test_check_lock_freshness_fresh_lock() {
-        use mozart_registry::lockfile::LockFile;
+        use mozart_core::repository::lockfile::LockFile;
         use tempfile::tempdir;
 
         let dir = tempdir().unwrap();
@@ -614,7 +614,7 @@ mod tests {
 
     #[test]
     fn test_check_lock_freshness_stale_lock() {
-        use mozart_registry::lockfile::LockFile;
+        use mozart_core::repository::lockfile::LockFile;
         use tempfile::tempdir;
 
         let dir = tempdir().unwrap();
diff --git a/crates/mozart/src/composer.rs b/crates/mozart/src/composer.rs
index 108a5d3..337b053 100644
--- a/crates/mozart/src/composer.rs
+++ b/crates/mozart/src/composer.rs
@@ -17,7 +17,7 @@ use crate::factory::create_composer;
 use mozart_core::composer::{AutoloadGenerator, InstallationManager, Locker, RepositoryManager};
 use mozart_core::config::Config;
 use mozart_core::package::RawPackageData;
-use mozart_registry::download_manager::DownloadManager;
+use mozart_core::repository::download_manager::DownloadManager;
 
 /// Project-level Composer state. Mirrors `Composer\PartialComposer` /
 /// `Composer\Composer` in PHP, exposing the subset of getters command
diff --git a/crates/mozart/src/factory.rs b/crates/mozart/src/factory.rs
index 67fc9a3..ca46671 100644
--- a/crates/mozart/src/factory.rs
+++ b/crates/mozart/src/factory.rs
@@ -17,7 +17,7 @@ use mozart_core::composer::{
 use mozart_core::config::resolve_references;
 use mozart_core::factory::create_config;
 use mozart_core::package::read_from_file;
-use mozart_registry::download_manager::DownloadManager;
+use mozart_core::repository::download_manager::DownloadManager;
 
 /// Rust port of `Factory::createComposer()`.
 ///
diff --git a/crates/mozart/tests/installer.rs b/crates/mozart/tests/installer.rs
index 78772fb..970fce4 100644
--- a/crates/mozart/tests/installer.rs
+++ b/crates/mozart/tests/installer.rs
@@ -15,8 +15,8 @@ use clap::Parser;
 use mozart::commands::{Cli, Commands, install, update};
 use mozart_core::console::Console;
 use mozart_core::exit_code::MozartError;
-use mozart_registry::installer_executor::TraceRecorderExecutor;
-use mozart_registry::repository::RepositorySet;
+use mozart_core::repository::installer_executor::TraceRecorderExecutor;
+use mozart_core::repository::repository::RepositorySet;
 use mozart_test_harness::{ParsedTest, parse_test_file};
 use tempfile::TempDir;