fix(presenter): 多根 r1 复审修四处（磁贴按自己根描述 / 挑 Java 按自己根要求 / 一拍一次扫描 / 只读内容级快照）（M274 r1）

crates/presenter/src/host/game/discovered.rs

@@ -167,19 +167,66 @@ pub(in crate::host) fn external_summary(
 /// （否则存档 / 模组 / 启动会退回配置根，那正是 M274 要修的错）。
 ///
 /// 不是 `ext-` 前缀的 id 直接返回 `None`（档案实例属于配置根，不需要反查）。
+///
+/// **代价**（M274 r1 复审实测过）：这是一次「每根扫一遍」的全树扫描。单实例动作（存档 / 模组 /
+/// 启动 / 改设置）走这里没问题，**但绝不能在 `instances()` 的循环里调**——那里用 [`Found`]
+/// 一拍只扫一遍（见它的文档）。
 #[must_use]
 pub(in crate::host) fn locate(env: &HostEnv, id: &str) -> Option<(GameRoot, String)> {
-    if !crate::dto::is_discovered_instance(id) {
-        return None;
+    Found::scan(env)
+        .find(id)
+        .map(|(root, version_id)| (root.clone(), version_id.to_string()))
+}
+
+/// **一拍之内**的发现快照：每个根只扫一遍 `versions/`，之后所有「这个 id 属于哪个根」都是内存查表。
+///
+/// 为什么要有它（M274 r1 复审 P2-1 的实测）：把反查直接写进 `instances()` 的循环里，扫描次数是
+/// `#根 × (1 + #ext 档案)`；官方根 200 个版本 + 10 份 `ext-` 档案时 `instances()` 从 236ms 涨到
+/// 1.35s（×5.7）。这里把「根 × 版本」的清单一次性读完，反查退化成线性的字符串比较
+/// （`ext-` id 是 16 位十六进制，逐条比一遍远比再扫一次盘便宜）。
+///
+/// 快照是**快照**：一拍里盘变了（用户同时在装版本）不会看到，下一次刷新重建。
+pub(in crate::host) struct Found {
+    roots: Vec<(GameRoot, Vec<String>)>,
+}
+
+impl Found {
+    /// 扫一遍全部根（配置根在前，顺序与 `roots::all` 一致）。
+    pub(in crate::host) fn scan(env: &HostEnv) -> Self {
+        let roots = roots::all(env)
+            .into_iter()
+            .map(|root| {
+                let versions = external_versions(env, root.game());
+                (root, versions)
+            })
+            .collect();
+        Self { roots }
     }
-    for root in roots::all(env) {
-        for version_id in external_versions(env, root.game()) {
-            if external_instance_id(root.key(), &version_id) == id {
-                return Some((root, version_id));
-            }
+
+    /// 逐个根 + 它这一拍扫到的版本 id（字典序，已滤掉不可登记的）。
+    pub(in crate::host) fn roots(&self) -> impl Iterator<Item = (&GameRoot, &[String])> {
+        self.roots
+            .iter()
+            .map(|(root, versions)| (root, versions.as_slice()))
+    }
+
+    /// id → (根, 版本 id)。不是 `ext-` 前缀 / 扫不到 ⇒ `None`。
+    pub(in crate::host) fn find(&self, id: &str) -> Option<(&GameRoot, &str)> {
+        if !crate::dto::is_discovered_instance(id) {
+            return None;
         }
+        self.roots().find_map(|(root, versions)| {
+            versions
+                .iter()
+                .find(|version_id| external_instance_id(root.key(), version_id) == id)
+                .map(|version_id| (root, version_id.as_str()))
+        })
+    }
+
+    /// id → 那个根的布局（查不到 ⇒ `None`，由调用方决定退回哪个根）。
+    pub(in crate::host) fn game_of(&self, id: &str) -> Option<&GameLayout> {
+        self.find(id).map(|(root, _)| root.game())
     }
-    None
 }
 
 /// 实例所属的那个根的布局（读盘路径的唯一入口）。
@@ -187,8 +234,9 @@ pub(in crate::host) fn locate(env: &HostEnv, id: &str) -> Option<(GameRoot, Stri
 /// 档案实例、以及「反查不到」的 id 一律退回配置根 `env.game`——**没有第二个答案**：
 /// 宁可读配置根（旧行为），也不把实例指向一个猜出来的目录。
 pub(in crate::host) fn game_for(env: &HostEnv, id: &str) -> GameLayout {
-    locate(env, id)
-        .map(|(root, _)| root.game().clone())
+    Found::scan(env)
+        .game_of(id)
+        .cloned()
         .unwrap_or_else(|| env.game.clone())
 }
 

crates/presenter/src/host/game/roots.rs

@@ -15,10 +15,25 @@
 //! 3. **去掉 `\\?\` 前缀**——Windows 的 `canonicalize` 一律返回 verbatim 形式（`\\?\C:\…`），
 //!    不去掉的话「同一路径的两种写法」永远不相等（这是个已知坑，用例
 //!    `junction_to_the_same_folder_is_one_root` 钉住）；
-//! 4. Windows / macOS 折成小写（大小写不敏感的文件系统）。
+//! 4. Windows / macOS 折成小写。
+//!
+//! # 已知取舍（这是**我们**的选择，不是文件系统性质）
+//!
+//! 第 4 步折小写是为了让 `C:\Mc` 与 `c:\mc`（Windows 上同一个目录）算同一个根。代价在 macOS：
+//! **APFS 可以按卷选择区分大小写**，那种卷上 `/a` 与 `/A` 是两个真实不同的目录，折小写会把它们
+//! 并成一个键 ⇒ 第二个根（官方位置）被**静默跳过**（不报错、不列它的实例）。触发条件只有
+//! 「用户在区分大小写的 APFS 卷上，且两个根只差大小写」——那种布局几乎不可能是真实安装，
+//! 所以接受这个代价：宁可漏一个根，也不要把同一批实例列两遍（后者是更常见的错）。
+//!
+//! 另外三条边界（都不是缺陷，记在这里免得下次重新推一遍）：
+//! - `\\?\UNC\server\share` 剥前缀后成 `unc/server/share`：仍然**唯一**、不会误合并，
+//!   只是丢了 UNC 语义（键只用于相等比较，不再当路径用）；
+//! - `\\?\C:\` 去掉尾斜杠之后是 `c:`：与 `c:/foo` 这类前缀不相同，不会撞；
+//! - Linux 的 `/`：去尾斜杠会得到空串，有兜底写回 `"/"`。
 //!
 //! `canonicalize` 失败（根还不存在）时退化成「字面量归一」：`\`→`/`、去尾斜杠、折小写。
-//! 尚不存在的目录没有短名/链接可解析，这一步够用。
+//! 尚不存在的目录没有短名/链接可解析，这一步够用；代价是那个目录**创建之后**键可能变一次
+//! （短名 → 长名、大小写归到真实名字），于是该根下已发现的实例 id 会变一次。
 //!
 //! # 只读
 //!
@@ -102,6 +117,7 @@ pub(in crate::host) fn key_of(path: &Path) -> String {
     let resolved: PathBuf = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());
     let text = resolved.to_string_lossy().replace('\\', "/");
     // verbatim 前缀（`\\?\C:\…` 在上一步已经变成 `//?/C:/…`）：不去掉就与普通写法永不相等。
+    // UNC 会因此变成 `unc/server/share`（仍唯一，见模块文档的「已知取舍」）。
     let text = text
         .strip_prefix("//?/")
         .or_else(|| text.strip_prefix("//./"))

crates/presenter/src/host/game/tests_multiroot.rs

@@ -1,4 +1,4 @@
-//! M274：**多根发现**（配置根 + 官方启动器的标准位置）的判据用例。
+//! M274：**多根发现**（只读那条用例在 `tests_multiroot2.rs`：升级成内容级快照，M274 r1 P2-3）（配置根 + 官方启动器的标准位置）的判据用例。
 //!
 //! 用户原话：「其他第三方启动器甚至能自动读到官方启动器的版本和存档」。官方启动器用的是
 //! `%APPDATA%\.minecraft`，便携模式的 ULL 用的是 `<exe>/.minecraft`——两个不同的目录。
@@ -12,7 +12,6 @@
 //! | [`the_same_version_in_two_roots_is_two_instances`] | 两个根里的同名版本 = **2 条**磁贴、id 不同、各自指向自己的根、名字分辨得出来 | 真实官方安装的目录形状（`launcher_profiles.json` / 加密的账户文件一概不读） |
 //! | [`a_junction_to_the_configured_root_is_not_a_second_root`] | 同一路径的第二种写法（junction / 符号链接）**不许**让同一批实例列两遍 | 8.3 短名（用例盘上造不出来；判据靠 `canonicalize` 的长名展开，见 `roots::key_of` 的文档） |
 //! | [`saves_come_from_the_instance_own_root`] | 每个实例的存档 / 截图列表只来自**它自己那个根**（不许把外部实例的存档当成当前根的） | 游戏进程正在跑时的文件锁 / 半写状态（未处理，见报告） |
-//! | [`discovery_writes_nothing_into_the_official_root`] | 只读发现：`instances()` + 列存档前后，官方根里一个条目都不许多 | 「官方启动器同时也在写」的并发（TOCTOU 本来就看不到） |
 //! | [`a_lazily_created_profile_stays_on_its_own_root`] | 懒创建档案（用户第一次改设置）之后 id → 根的反查不退化，且没把配置根的同名版本一并抹掉 | 档案里**没有**根字段这一事实本身（根只从 id 反查，见 `discovered::locate`） |
 //! | [`the_launch_reads_the_manifest_from_the_instance_root`] | 启动装配的清单 / 运行目录走实例自己的根 | 真的把游戏拉起来（要真 jvm / 账号 / 网络） |
 
@@ -45,28 +44,6 @@ mod temp {
             let _ = std::fs::remove_dir_all(Path::new(&self.0));
         }
     }
-
-    /// 目录下所有条目（排序后比较，用来做「读盘前后」快照）。
-    pub fn entries_under(dir: &Path) -> Vec<String> {
-        let mut out = Vec::new();
-        let mut stack = vec![dir.to_path_buf()];
-        while let Some(current) = stack.pop() {
-            let Ok(read) = std::fs::read_dir(&current) else {
-                continue;
-            };
-            for entry in read.flatten() {
-                let path = entry.path();
-                if let Ok(relative) = path.strip_prefix(dir) {
-                    out.push(relative.to_string_lossy().replace('\\', "/"));
-                }
-                if path.is_dir() {
-                    stack.push(path);
-                }
-            }
-        }
-        out.sort();
-        out
-    }
 }
 
 /// 造两个根：配置根 = `<root>/.minecraft`，官方位置 = `<root>/official/.minecraft`。
@@ -269,36 +246,6 @@ fn saves_come_from_the_instance_own_root() {
     );
 }
 
-// ------------------------------------------------------------ 判据④：只读发现（官方根零写入）
-
-/// 浏览（列实例 + 列存档）不许在官方根里留下任何东西，也不许凭空写 `profiles.json`。
-#[test]
-fn discovery_writes_nothing_into_the_official_root() {
-    let (_root, env) = two_roots("ull-host-multiroot-readonly");
-    write_version(&env.game, "A");
-    write_version(&GameLayout::new(official(&env)), "A");
-    write_world(&official(&env), "official-world");
-
-    let before = temp::entries_under(&official(&env));
-    let snapshot = instances(&env);
-    for tile in &snapshot {
-        if let Ok(dir) = super::super::saves::run_dir(&env, tile) {
-            let _ = super::super::saves::snapshot(tile, &dir, None);
-        }
-    }
-    assert_eq!(
-        before,
-        temp::entries_under(&official(&env)),
-        "读一次实例列表 / 存档就在官方启动器的目录里多出了东西"
-    );
-    let profiles = read_profiles(&env.layout).expect("读档案");
-    assert!(
-        profiles.profiles.is_empty(),
-        "浏览不该懒创建档案：{:?}",
-        profiles.profiles
-    );
-}
-
 // ------------------------------------------- 判据⑤：懒创建的档案仍认自己那个根（不吞同名）
 
 /// 用户第一次给官方根里的实例改设置 ⇒ 懒创建档案，但：

crates/presenter/src/host/game/tests_multiroot2.rs

@@ -0,0 +1,332 @@
+//! M274 **r1 复审**补的判据（P1-1 / P1-2 / P2-3）。
+//!
+//! 上一轮（`tests_multiroot.rs`）钉的是「两个根里的同名版本是两条实例、各自的书架/存档/启动按自己
+//! 那个根解析」。复审把「同一句话没走完」的两处揪了出来——**根身份有了，但两处「描述 / 前置要求」
+//! 还在读配置根**——这一组就是那两处，加上「只读」那条升级成内容级快照。
+//!
+//! | 用例 | 抓得住什么 | 抓不住什么 |
+//! |---|---|---|
+//! | [`the_tile_describes_a_lazily_created_profile_from_its_own_root`] | 官方根实例被懒创建成档案之后，磁贴的 `version_present` / `isolation` / `mc_version` **逐项不变**（复审 P1-1 的三项同时错：显示与行为分叉） | 磁贴之外的显示（`element` 没有内省接口，见 `pages/instances/tests` 的口径） |
+//! | [`pick_java_reads_the_requirement_from_the_instance_own_root`] | 启动挑 Java 时读的是**实例自己那个根**的 `javaVersion`（复审 P1-2：配置根读出来 8，实例是 21，实际选中 17） | 真的有 21 的 JDK 被选中（那要装 JDK；这里钉的是「要求」与回落，不是 `pick` 的最优选择） |
+//! | [`nothing_is_written_into_the_official_root`] | 列实例 / 列存档 / 装配启动 / 懒创建档案之后，官方根的**文件内容、大小、mtime** 一个都没变（复审 P2-3：原来只比条目名） | natives 解压（那发生在 `Launcher::spawn`，用例不拉进程）；官方启动器同时在写的并发（TOCTOU） |
+
+use std::path::{Path, PathBuf};
+
+use unlucky_core::game::GameLayout;
+
+use super::*;
+
+/// 临时根（每个用例一个目录；断言 panic 时也会删）。
+mod temp {
+    use std::path::{Path, PathBuf};
+    use std::sync::atomic::{AtomicU64, Ordering};
+
+    pub struct Root(pub PathBuf);
+
+    impl Root {
+        pub fn new(tag: &str) -> Self {
+            static COUNTER: AtomicU64 = AtomicU64::new(0);
+            let seq = COUNTER.fetch_add(1, Ordering::Relaxed);
+            let path = std::env::temp_dir().join(format!("{tag}-{}-{seq}", std::process::id()));
+            let _ = std::fs::remove_dir_all(&path);
+            std::fs::create_dir_all(&path).expect("建临时目录");
+            Self(path)
+        }
+    }
+
+    impl Drop for Root {
+        fn drop(&mut self) {
+            let _ = std::fs::remove_dir_all(Path::new(&self.0));
+        }
+    }
+}
+
+/// 造两个根：配置根 = `<root>/.minecraft`，官方位置 = `<root>/official/.minecraft`。
+fn two_roots(tag: &str) -> (temp::Root, HostEnv) {
+    let root = temp::Root::new(tag);
+    let mut env = HostEnv::at_root(&root.0);
+    let official = root.0.join("official").join(".minecraft");
+    std::fs::create_dir_all(&official).expect("官方根目录");
+    env.standard_game = Some(official);
+    (root, env)
+}
+
+/// 官方根（＝第二个候选根）的**字面**路径。
+fn official(env: &HostEnv) -> PathBuf {
+    env.standard_game.clone().expect("用例里一定钉了官方根")
+}
+
+/// 官方根 + 配置根各自的布局。
+fn official_layout(env: &HostEnv) -> GameLayout {
+    GameLayout::new(official(env))
+}
+
+fn write_manifest(game: &GameLayout, id: &str, json: &str) {
+    let path = game.version_json(id);
+    std::fs::create_dir_all(path.parent().expect("版本目录")).expect("版本目录");
+    std::fs::write(&path, json).expect("写版本 JSON");
+}
+
+// ---------------------------------------------------------------- 判据①（P1-1）：磁贴按自己那个根描述
+
+/// 官方根里的实例被懒创建成档案之后，磁贴的三格必须**逐项不变**。
+///
+/// 复审 P1-1 的探针（夹具几乎一样）：`version_present` true→false、`isolation` isolated→shared、
+/// `mc_version` `1.20.4`→`A`。三格同时错，而实际读盘（saves / mods / launch）走 `game_for` 是对的
+/// ⇒ **显示与行为分叉**：用户以为存档在 ULL 便携根，实际在官方根。
+///
+/// 变异证明：把 `profile_summary` 的 `home.unwrap_or(&env.game)` 改回 `&env.game` 就红。
+#[test]
+fn the_tile_describes_a_lazily_created_profile_from_its_own_root() {
+    let (_root, env) = two_roots("ull-host-multiroot2-tile");
+    // 官方根：`A` 继承 `1.20.4`，且 `versions/A/mods/` 存在（版本隔离形态）。配置根里**没有** `A`。
+    let official = official_layout(&env);
+    write_manifest(&official, "1.20.4", r#"{"id":"1.20.4","type":"release"}"#);
+    write_manifest(
+        &official,
+        "A",
+        r#"{"id":"A","inheritsFrom":"1.20.4","type":"release"}"#,
+    );
+    std::fs::create_dir_all(official.version_dir("A").join("mods")).expect("mods 目录");
+
+    // `1.20.4` 本身也是个可登记的版本 ⇒ 列表里会有它；这里只盯 `A`。
+    let before = instances(&env);
+    let before = before
+        .iter()
+        .find(|tile| tile.version_id == "A")
+        .expect("`A` 在列表里")
+        .clone();
+    assert_eq!(before.mc_version, "1.20.4", "继承链要走到父版本");
+    assert!(before.version_present, "清单在官方根里");
+    assert_eq!(
+        before.isolation, "isolated",
+        "`versions/A/mods/` 是自带数据的痕迹"
+    );
+
+    // 用户第一次改这个实例（写启动参数 = 懒创建档案，**不**写隔离档）——正是「官方实例」的常态路径。
+    let patch = crate::dto::LaunchArgsPatch {
+        jvm_args: Some("-XX:+UseG1GC".to_string()),
+        ..crate::dto::LaunchArgsPatch::default()
+    };
+    let mut host = super::super::CoreHost::headless(env.clone());
+    host.apply_launch_args(&before.id, &patch)
+        .expect("官方根实例写启动参数不该报「找不到实例」");
+
+    let after = instances(&env);
+    let after = after
+        .iter()
+        .find(|tile| tile.id == before.id)
+        .expect("懒创建之后同一条实例还在");
+    assert_eq!(
+        instances(&env).len(),
+        2,
+        "懒创建之后不该多出第三条（`1.20.4` + `A` 就是全部）"
+    );
+    assert_eq!(
+        after.version_present, before.version_present,
+        "`version_present` 变了（磁贴会显示「文件缺失」）：{before:?} → {after:?}"
+    );
+    assert_eq!(
+        after.isolation, before.isolation,
+        "`isolation` 变了（启动提示会说错运行目录）：{before:?} → {after:?}"
+    );
+    assert_eq!(
+        after.mc_version, before.mc_version,
+        "`mc_version` 变了（继承链丢了）：{before:?} → {after:?}"
+    );
+    assert_eq!(
+        after.launch.jvm_args, "-XX:+UseG1GC",
+        "写回的那一项要读得到"
+    );
+}
+
+// ---------------------------------------------------------------- 判据②（P1-2）：挑 Java 按自己那个根
+
+/// 两个根里各一个**同名**版本，`javaVersion` 要求不同 ⇒ 各自按自己那个根的要求回落。
+///
+/// 复审 P1-2 的探针：官方根里的自定义名版本声明 `javaVersion.majorVersion = 21`，配置根读不到清单
+/// ⇒ 退回静态表 ⇒ `minimum = 8` ⇒ 实际选中 17，把要 21 的 modpack 拉起来。
+///
+/// 用「显式路径探测失败」这条确定性回落（`probe` 拿不到版本 ⇒ `major = required.minimum`），
+/// 所以不需要机器上真的装着 JDK 8/21：断言的是**要求**与回落，不是 `pick` 的最优选择。
+#[test]
+fn pick_java_reads_the_requirement_from_the_instance_own_root() {
+    let (_root, env) = two_roots("ull-host-multiroot2-java");
+    let official = official_layout(&env);
+    write_manifest(
+        &env.game,
+        "A",
+        r#"{"id":"A","javaVersion":{"majorVersion":8}}"#,
+    );
+    write_manifest(
+        &official,
+        "A",
+        r#"{"id":"A","javaVersion":{"majorVersion":21}}"#,
+    );
+
+    let tiles = instances(&env);
+    assert_eq!(tiles.len(), 2, "{tiles:?}");
+    // 探测必然失败（路径不存在）⇒ 落回「版本要求」。
+    let missing = Path::new("Z:/ull-no-such-java/bin/java.exe");
+    let mut majors: Vec<u32> = tiles
+        .iter()
+        .map(|tile| {
+            let game = game_for(&env, &tile.id);
+            super::super::launch::pick_java(&env, &game, "A", Some(missing))
+                .selection
+                .major
+        })
+        .collect();
+    majors.sort_unstable();
+    assert_eq!(
+        majors,
+        vec![8, 21],
+        "两个根里的同名版本要求不同，挑 Java 必须各读各自的清单"
+    );
+
+    // 变异证明：拿配置根去读官方根那个实例 ⇒ 只会得到 8（复审实测这条会导致 17 去跑要 21 的包）。
+    let wrong = super::super::launch::pick_java(&env, &env.game, "A", Some(missing));
+    assert_eq!(
+        wrong.selection.major, 8,
+        "按配置根读会挑错——这条断言钉住「错在哪」"
+    );
+
+    // **走真启动装配**（`build_request` → `pick_java`）：这条才抓得住「调用点传错根」。
+    // 每个实例在自己的设置里钉一个探测必然失败的 java 路径 ⇒ 生效的 major 就是它自己那个根的要求。
+    let mut majors: Vec<u32> = Vec::new();
+    for tile in &tiles {
+        crate::host::launch_args::apply(
+            &env,
+            &tile.id,
+            &tile.version_id,
+            &crate::dto::LaunchArgsPatch {
+                java_path: Some(missing.display().to_string()),
+                ..crate::dto::LaunchArgsPatch::default()
+            },
+        )
+        .expect("钉 java 路径");
+        let target = super::super::launch::LaunchTarget {
+            id: tile.id.clone(),
+            name: tile.name.clone(),
+            version_id: tile.version_id.clone(),
+            account: None,
+        };
+        let (request, _warnings) =
+            super::super::launch::build_request(&env, &target).expect("装配应当成功");
+        majors.push(request.java.major);
+    }
+    majors.sort_unstable();
+    assert_eq!(
+        majors,
+        vec![8, 21],
+        "启动装配读的必须是实例自己那个根的要求（调用点传 `env.game` 就会全是 8）"
+    );
+}
+
+// ---------------------------------------------------------------- 判据③（P2-3）：只读发现升级成内容级
+
+/// **内容级**快照：相对路径 + 字节数 + mtime(ms) + 内容哈希（fnv-1a）。
+///
+/// 为什么不是只比条目名（复审 P2-3）：只比名字抓得住「多出新文件」，抓不住「已有文件被覆盖」
+/// ——natives 的 dll 被改写、mtime 被刷新这两种都漏。这里四样一起比：内容改一个字节、大小变、
+/// mtime 变都会红。
+fn content_snapshot(dir: &Path) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut stack = vec![dir.to_path_buf()];
+    while let Some(current) = stack.pop() {
+        let Ok(read) = std::fs::read_dir(&current) else {
+            continue;
+        };
+        for entry in read.flatten() {
+            let path = entry.path();
+            let Ok(relative) = path.strip_prefix(dir) else {
+                continue;
+            };
+            let name = relative.to_string_lossy().replace('\\', "/");
+            if path.is_dir() {
+                out.push(format!("{name}|dir"));
+                stack.push(path);
+                continue;
+            }
+            let meta = std::fs::metadata(&path).ok();
+            let bytes = meta.as_ref().map_or(0, std::fs::Metadata::len);
+            let mtime = meta
+                .and_then(|meta| meta.modified().ok())
+                .and_then(|time| time.duration_since(std::time::UNIX_EPOCH).ok())
+                .map(|elapsed| elapsed.as_millis())
+                .unwrap_or(0);
+            let content = std::fs::read(&path).unwrap_or_default();
+            let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
+            for byte in content {
+                hash ^= u64::from(byte);
+                hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
+            }
+            out.push(format!("{name}|{bytes}|{mtime}|{hash:016x}"));
+        }
+    }
+    out.sort();
+    out
+}
+
+/// 列实例 / 列存档 / 装配启动 / 懒创建档案之后，官方根里**一个字节都不许变**，也不许凭空建档案。
+///
+/// 升级点（复审 P2-3）：原来只比条目名集合，现在比「相对路径 + 大小 + mtime + 内容哈希」，
+/// 并且把「懒创建档案」这条写盘路径也带进来（那是本 mission 唯一会在用户动作后写盘的地方，
+/// 而它必须写进 `.ULL`、不碰官方根）。
+///
+/// 抓不住：`Launcher::spawn` 解压 natives（用例不拉进程）；官方启动器同时在写的并发（TOCTOU）。
+#[test]
+fn nothing_is_written_into_the_official_root() {
+    let (_root, env) = two_roots("ull-host-multiroot2-readonly");
+    let official = official_layout(&env);
+    write_manifest(&official, "1.20.4", r#"{"id":"1.20.4","type":"release"}"#);
+    write_manifest(
+        &official,
+        "A",
+        r#"{"id":"A","inheritsFrom":"1.20.4","mainClass":"net.minecraft.client.main.Main"}"#,
+    );
+    // 一个已经在的 natives 文件（正是「被覆写」这种错要抓的东西）。
+    let natives = official.version_dir("A").join("natives");
+    std::fs::create_dir_all(&natives).expect("natives 目录");
+    std::fs::write(natives.join("lwjgl.dll"), b"original-content").expect("natives 落盘");
+    let world = official.root().join("saves").join("world");
+    std::fs::create_dir_all(&world).expect("世界目录");
+    std::fs::write(world.join("level.dat"), b"fixture").expect("level.dat");
+
+    let before = content_snapshot(official.root());
+
+    // ① 列实例 ② 列存档（含截图目录扫） ③ 装配启动请求（natives 解压发生在 spawn，不在装配里）
+    let snapshot = instances(&env);
+    let tile = snapshot
+        .iter()
+        .find(|tile| tile.version_id == "A")
+        .expect("`A` 在列表里");
+    for tile in &snapshot {
+        if let Ok(dir) = super::super::saves::run_dir(&env, tile) {
+            let _ = super::super::saves::snapshot(tile, &dir, None);
+        }
+        let target = super::super::launch::LaunchTarget {
+            id: tile.id.clone(),
+            name: tile.name.clone(),
+            version_id: tile.version_id.clone(),
+            account: None,
+        };
+        let _ = super::super::launch::build_request(&env, &target);
+    }
+    // ④ 用户改一次设置 ⇒ 懒创建档案（写盘必须落 `.ULL`）
+    set_isolation(&env, &tile.id, "isolated").expect("懒创建档案");
+    let _ = instances(&env);
+
+    assert_eq!(
+        before,
+        content_snapshot(official.root()),
+        "官方根的条目 / 大小 / mtime / 内容有任何一格变了（发现与设置都只许读它）"
+    );
+    let profiles = read_profiles(&env.layout).expect("读档案");
+    assert_eq!(profiles.profiles.len(), 1, "档案落在 .ULL 里");
+    assert!(
+        env.layout.profiles_config().starts_with(env.layout.home()),
+        "档案路径必须在 .ULL 内：{}",
+        env.layout.profiles_config().display()
+    );
+}