fix: address 4 review issues on install integrity

1. is_install_complete: handle mcpplibs nested layout (single subdir
   with src/ or mcpp.toml), prevents false deletion of old packages

2. copy_from_global: check return value and verify completeness
   before marking .mcpp_ok; clean partial copies on failure

3. Restore !inst error propagation in resolve_xpkg_path — don't
   mask xlings launch/protocol errors behind generic "payload missing"

4. Per-command bootstrap gating: check_base_init is deferred to
   get_cfg(requireBootstrap=true) in build/run/toolchain-install,
   not run globally in load_or_init. Light commands (self env,
   toolchain list) skip the check.

Author: Sunrisepeak

src/cli.cppm

@@ -1139,13 +1139,25 @@ prepare_build(bool print_fingerprint,
     //   3. PATH g++  (with warning)
     std::filesystem::path explicit_compiler;
     std::optional<mcpp::config::GlobalConfig> cfg_opt;
-    auto get_cfg = [&]() -> std::expected<mcpp::config::GlobalConfig*, std::string> {
+    bool bootstrap_checked = false;
+    auto get_cfg = [&](bool requireBootstrap = true) -> std::expected<mcpp::config::GlobalConfig*, std::string> {
         if (!cfg_opt) {
             auto c = mcpp::config::load_or_init(/*quiet=*/false,
                 make_bootstrap_progress_callback());
             if (!c) return std::unexpected(c.error().message);
             cfg_opt = std::move(*c);
         }
+        // Commands that need bootstrap tools (build, run, toolchain install)
+        // pass requireBootstrap=true to get an early, clear error.
+        if (requireBootstrap && !bootstrap_checked) {
+            bootstrap_checked = true;
+            auto problem = mcpp::config::check_base_init(*cfg_opt);
+            if (!problem.empty()) {
+                return std::unexpected(std::format(
+                    "{}\n  hint: run `mcpp self init --force` to reset and re-initialize",
+                    problem));
+            }
+        }
         return &*cfg_opt;
     };
 

src/config.cppm

@@ -558,14 +558,10 @@ std::expected<GlobalConfig, ConfigError> load_or_init(
         }
     }
 
-    // 8. Verify bootstrap completed. Warn (don't block) if something is
-    //    missing — commands like `mcpp self env` should still work even
-    //    if bootstrap tools (patchelf/ninja) failed to download.
-    auto initProblem = check_base_init(cfg);
-    if (!initProblem.empty() && !quiet) {
-        std::println(stderr, "warning: {}", initProblem);
-        std::println(stderr, "  hint: run `mcpp self init --force` to reset and re-initialize");
-    }
+    // 8. Bootstrap check is NOT done here — it's deferred to commands that
+    //    actually need bootstrap tools (build, run, toolchain install).
+    //    Light commands (self env, toolchain list) should work even if
+    //    bootstrap is incomplete. Commands call check_base_init() themselves.
 
     return cfg;
 }

src/fallback/install_integrity.cppm

@@ -67,10 +67,26 @@ bool is_install_complete(const std::filesystem::path& xpkgDir) {
 
     // Backward compat: no marker but has content directories
     // (installed before this feature was added)
+    // Check top-level content dirs (xim toolchain packages).
     for (auto dir : {"bin", "lib", "lib64", "include", "share"}) {
         if (std::filesystem::exists(xpkgDir / dir))
             return true;
     }
+    // Check for mcpplibs layout: single subdirectory containing src/ or
+    // mcpp.toml (extracted tarball). E.g. verdir/cmdline-0.0.1/src/...
+    std::error_code ec;
+    std::vector<std::filesystem::path> subs;
+    for (auto& e : std::filesystem::directory_iterator(xpkgDir, ec)) {
+        if (e.is_directory()) subs.push_back(e.path());
+    }
+    if (subs.size() == 1) {
+        auto& sub = subs[0];
+        if (std::filesystem::exists(sub / "src")
+         || std::filesystem::exists(sub / "mcpp.toml")
+         || std::filesystem::exists(sub / "include")
+         || std::filesystem::exists(sub / "bin"))
+            return true;
+    }
     return false;
 }
 

src/pm/package_fetcher.cppm

@@ -665,25 +665,32 @@ Fetcher::resolve_xpkg_path(std::string_view target,
         };
         mcpp::log::verbose("fetcher", std::format("xlings install: {}", targets[0]));
         auto inst = install(targets, handler);
-        if (inst && inst->exitCode == 0 && std::filesystem::exists(verdir)) {
+        if (!inst) {
+            // xlings launch/protocol failure — propagate the real error,
+            // don't mask it behind a generic "payload missing".
+            return std::unexpected(inst.error());
+        }
+        if (inst->exitCode == 0 && std::filesystem::exists(verdir)) {
             mcpp::fallback::mark_install_complete(verdir);
             return make_payload();
         }
         // Install failed → clean residue so next attempt starts fresh.
         mcpp::fallback::clean_incomplete_install(verdir);
-        if (inst && inst->exitCode != 0) {
+        if (inst->exitCode != 0) {
             mcpp::log::warn("fetcher", std::format(
                 "xlings install exit={}, trying fallback", inst->exitCode));
         }
     }
 
     // 4. Copy fallback: xlings may have installed into its global data dir.
-    mcpp::fallback::copy_xpkg_from_global(verdir);
-    if (std::filesystem::exists(verdir)) {
+    bool copyOk = mcpp::fallback::copy_xpkg_from_global(verdir);
+    if (copyOk && mcpp::fallback::is_install_complete(verdir)) {
         mcpp::fallback::mark_install_complete(verdir);
         mcpp::log::verbose("fetcher", "resolved via copy fallback");
         return make_payload();
     }
+    // Copy failed or incomplete — clean partial copy.
+    mcpp::fallback::clean_incomplete_install(verdir);
 
     return std::unexpected(CallError{
         std::format("xpkg payload missing: {}\n"