fix(m165): forget 之后让自更新也换引擎（复审 P2-1）+ 卡口计数与端到端守卫

复审 P2-1（采「修法 1」，不是只改措辞）：`shared::forget` 只让登记处不再持有
那一份，换不掉自更新 `Factory` 里常驻的 Arc —— 于是「重新检测地区」对更新路径
不生效，直到重启。现在设置动作会把 Factory 一起重建。

- presenter/update_state: `Runtime::rebuild_factory` + `CoreHost::refresh_update_factory`；
  只换 factory，不动 view/inflight（在飞的 Job 派发时已克隆走装配，重建不打断它）
- presenter/dispatch: `SetSetting` 成功且键是「重新检测地区」时调 refresh
- presenter/engine: `DETECT_REGION_ACTION` 常量（设置页行 id / set 分派 / dispatch
  判断共用）；放这里而不是 settings.rs 是因为后者已到 400 行红线
- core/shared: 文档改准 —— forget 的范围是「登记处不再持有」，长命持有者必须自己重建；
  记账从 `engine_for` 移到 `DownloadEngine::new` 这个卡口（分两把锁，避免自锁），
  于是 `constructions` 连绕过登记处另造引擎的调用点也统得住

守卫（都做了变异实证）：
- update_tests::detect_region_rebuilds_the_update_factory_engine：走真实命令路径
  `AppCommand::SetSetting` → 断言 Factory 换了引擎且指向登记处当前实例；变异（删掉
  dispatch 里那句 refresh）→ 红在 Arc::ptr_eq
- update_tests::rebuilding_the_factory_does_not_touch_a_running_job：重建不清
  inflight、不改快照，在飞 Job 仍能跑完
- addon/http::tests::three_host_request_paths_share_one_engine：连走三条真实宿主路径
  （Modrinth 元数据 GET / CF 带 header GET / Java 页渲染）后 constructions == 1；
  变异（让 get_via_engine 自己造引擎）→ 红，left:2 right:1

顺带修：settings.rs 在上一提交被推到 403 行、engine.rs 401 行，两者都超
guards.yml 的 file-size 红线（>400 直接失败）。现在 settings.rs 400 / engine.rs 399，
全仓 `*.rs` 复跑「>400」扫描无输出。

验证：core lib 608 过、5 个 download 集成 target 42 过、presenter lib 270 过、
clippy --all-targets 干净、fmt 干净。真站点仍未打（见报告「没验的部分」）。

crates/core/src/download/engine.rs

@@ -74,6 +74,8 @@ impl DownloadEngine {
         let http = http::build_client(&cfg).unwrap_or_else(|_| reqwest::Client::new());
         let sem = Arc::new(Semaphore::new(cfg.max_concurrency.max(1)));
         let seed = now_ms() ^ (u64::from(cfg.max_concurrency as u32) << 32);
+        // 纯记账（M165）：卡在构造这个点上，才统计得到绕过登记处的调用点（守卫靠 `constructions`）。
+        super::shared::record_build(cache.root());
         Self {
             http,
             cfg,

crates/core/src/download/shared.rs

@@ -26,6 +26,12 @@
 //! * **活多久**：跟随进程。登记处**不做淘汰**——淘汰会让后续请求建出第二个引擎，同一个根上
 //!   同时存在两条连接池，等于把要修的问题换个地方复现。要让地区判定等「一次性派生值」重算，
 //!   用 [`forget`] 显式失效（设置页「重新检测地区」就这么做）。
+//! * **`forget` 到什么范围**：只让登记处不再持有那一份。**已经拿到 `Arc` 的人继续用旧的**：
+//!   短命请求自然结束（它们的窗口只有一次下载），但**长命持有者必须自己重建**——presenter 的
+//!   自更新子系统（`host::update::Factory`）从 `CoreHost::build` 起就把引擎存在字段里，
+//!   只 forget 的话它会一直用旧实例（含旧地区档案）直到进程结束。所以「重新检测地区」那条
+//!   设置动作除了 [`forget`] 还调 `CoreHost::refresh_update_factory()` 把新引擎接过去
+//!   （M165 复审 P2-1：这是本模块文档原先说漏的一半）。
 //! * **并发多少**：`EngineConfig::default().max_concurrency`（64）现在是**进程级**上限，
 //!   不再是「每请求 64」。单请求独占时与从前一致；多请求并发时它们分摊这 64 张许可。
 //! * **镜像切换 / 失效**：一律走引擎原有的候选规划 + 健康度冷却，本模块不参与判定；唯一可见的
@@ -39,7 +45,7 @@
 
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex, MutexGuard, OnceLock};
+use std::sync::{Arc, Mutex, OnceLock};
 
 use super::cache::{now_ms, ContentCache};
 use super::config::EngineConfig;
@@ -49,22 +55,19 @@ use super::mirrors::MirrorTable;
 use super::region::{decide_from, load_cached, store_cached};
 use super::region_system::detect_signals;
 
-/// 登记处：缓存根 → 引擎，外加「这个根建过几次引擎」（守卫/诊断用，**不**随淘汰清零）。
+/// 登记处：缓存根 → 引擎。
-#[derive(Debug, Default)]
+fn registry() -> &'static Mutex<HashMap<PathBuf, Arc<DownloadEngine>>> {
-struct Registry {
+    static ENGINES: OnceLock<Mutex<HashMap<PathBuf, Arc<DownloadEngine>>>> = OnceLock::new();
-    engines: HashMap<PathBuf, Arc<DownloadEngine>>,
+    ENGINES.get_or_init(|| Mutex::new(HashMap::new()))
-    builds: HashMap<PathBuf, usize>,
 }
 
-fn registry() -> &'static Mutex<Registry> {
+/// 「这个根建过几次引擎」的账本（守卫/诊断用，**不**随 [`forget`] 清零）。
-    static REGISTRY: OnceLock<Mutex<Registry>> = OnceLock::new();
+///
-    REGISTRY.get_or_init(|| Mutex::new(Registry::default()))
+/// 与 [`registry`] **分两把锁**：记账发生在 `DownloadEngine::new` 里（见 [`record_build`]），
-}
+/// 而 [`engine_for`] 是**持着**登记处那把锁去调构造的——合成一把锁就是自己等自己。
-
+fn ledger() -> &'static Mutex<HashMap<PathBuf, usize>> {
-fn lock() -> MutexGuard<'static, Registry> {
+    static BUILDS: OnceLock<Mutex<HashMap<PathBuf, usize>>> = OnceLock::new();
-    registry()
+    BUILDS.get_or_init(|| Mutex::new(HashMap::new()))
-        .lock()
-        .unwrap_or_else(|poisoned| poisoned.into_inner())
 }
 
 /// 缓存根的键：去掉尾部分隔符（`D:/x/cache` 与 `D:/x/cache/` 视作同一根）。
@@ -85,35 +88,54 @@ fn key_of(cache_root: &Path) -> PathBuf {
 #[must_use]
 pub fn engine_for(cache_root: impl AsRef<Path>) -> Arc<DownloadEngine> {
     let key = key_of(cache_root.as_ref());
-    let mut reg = lock();
+    let mut engines = registry()
-    if let Some(engine) = reg.engines.get(&key) {
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner());
+    if let Some(engine) = engines.get(&key) {
         return Arc::clone(engine);
     }
     let engine = Arc::new(build(&key));
-    reg.engines.insert(key.clone(), Arc::clone(&engine));
+    engines.insert(key, Arc::clone(&engine));
-    *reg.builds.entry(key).or_default() += 1;
     engine
 }
 
 /// 让该数据根的共享引擎失效（下次 [`engine_for`] 重新构造）。
 ///
-/// 在飞请求持有的 `Arc` 不受影响（它们继续用完手里那个引擎）；之后的新请求拿到新引擎，
+/// **只让登记处不再持有那一份**：已经拿到 `Arc` 的人继续用旧的。短命请求自然结束；长命持有者
-/// 于是「重新检测地区」这类一次性派生值能真的重算。返回是否真淘汰了一份。
+/// （presenter 的自更新 `Factory`）必须自己重建，否则它会一直用旧实例——本仓在「重新检测地区」
+/// 的设置动作里调 `CoreHost::refresh_update_factory()` 补上这一步（见模块文档「`forget` 到什么范围」）。
+/// 返回是否真淘汰了一份。
 pub fn forget(cache_root: impl AsRef<Path>) -> bool {
-    lock()
+    registry()
-        .engines
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner())
         .remove(&key_of(cache_root.as_ref()))
         .is_some()
 }
 
-/// 该数据根在本进程里**实际构造过几次引擎**。
+/// 记一笔「这个缓存根上又造了一个引擎」。
+///
+/// **唯一调用点是 [`DownloadEngine::new`]**（不是 [`engine_for`]）：记账卡在构造这个卡口上，
+/// 于是 [`constructions`] 统计的是**进程里真实发生过几次构造**，与「谁造的」无关。
+/// 若只在 `engine_for` 里记账，任何绕过登记处、自己 `DownloadEngine::new` 的调用点都统计不到
+/// （M165 复审备注 2 的诉求）。
+pub(crate) fn record_build(cache_root: &Path) {
+    *ledger()
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner())
+        .entry(key_of(cache_root))
+        .or_default() += 1;
+}
+
+/// 该数据根在本进程里**实际构造过几次引擎**（不论谁构造的）。
 ///
 /// 这是给守卫与诊断用的：跨请求复用成立时，同一个根无论被请求多少次，这个数都停在 `1`
 /// （`forget` 之后每重建一次 +1）。只断言「结果一样」测不出复用——引擎建几次都能下同一个文件。
 #[must_use]
 pub fn constructions(cache_root: impl AsRef<Path>) -> usize {
-    lock()
+    ledger()
-        .builds
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner())
         .get(&key_of(cache_root.as_ref()))
         .copied()
         .unwrap_or(0)

crates/presenter/src/host/addon/http.rs

@@ -126,3 +126,114 @@ pub(super) fn encode(raw: &str) -> String {
     }
     out
 }
+
+#[cfg(test)]
+mod tests {
+    use std::io::{Read as _, Write as _};
+    use std::net::TcpListener;
+    use std::time::Duration;
+
+    use unlucky_core::download::shared;
+
+    use super::get;
+    use crate::host::env::HostEnv;
+
+    /// 离线回环 HTTP 服务：只答固定 JSON，数「处理了几条请求 / 接了几条连接」。
+    ///
+    /// 用 127.0.0.1 而不是真站点：**单测不许打公网**（CI 没网，也不该有）。
+    fn loopback(expected_requests: usize) -> (String, std::sync::mpsc::Receiver<(usize, usize)>) {
+        let listener = TcpListener::bind("127.0.0.1:0").expect("绑定回环端口");
+        let addr = listener.local_addr().expect("取端口");
+        let (tx, rx) = std::sync::mpsc::channel();
+        std::thread::spawn(move || {
+            let mut conns = 0usize;
+            let mut requests = 0usize;
+            while requests < expected_requests {
+                let Ok((mut socket, _)) = listener.accept() else {
+                    break;
+                };
+                conns += 1;
+                let _ = socket.set_read_timeout(Some(Duration::from_secs(5)));
+                let mut seen = Vec::new();
+                loop {
+                    let mut chunk = [0u8; 1024];
+                    match socket.read(&mut chunk) {
+                        Ok(0) | Err(_) => break,
+                        Ok(read) => seen.extend_from_slice(&chunk[..read]),
+                    }
+                    if !seen.windows(4).any(|window| window == b"\r\n\r\n") {
+                        continue;
+                    }
+                    requests += 1;
+                    let body = br#"{"ok":true}"#;
+                    let head = format!(
+                        "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\n\r\n",
+                        body.len()
+                    );
+                    if socket.write_all(head.as_bytes()).is_err() || socket.write_all(body).is_err()
+                    {
+                        break;
+                    }
+                    seen.clear();
+                    if requests >= expected_requests {
+                        let _ = tx.send((conns, requests));
+                        return;
+                    }
+                }
+            }
+            let _ = tx.send((conns, requests));
+        });
+        (format!("http://{addr}/v2/search"), rx)
+    }
+
+    /// 一个只用来放缓存根的临时数据根（`<root>/.ULL/cache`）。
+    fn data_root(tag: &str) -> std::path::PathBuf {
+        static SEQ: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(0);
+        let seq = SEQ.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+        let dir = std::env::temp_dir().join(format!("ull-http-{tag}-{}-{seq}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(dir.join(".ULL").join("cache")).expect("建缓存根");
+        dir
+    }
+
+    /// **端到端守卫（M165 复审备注 2）**：连走三条真实宿主请求路径，只该构造一个引擎。
+    ///
+    /// 为什么不满足于「再断言一次 `engine()` 复用」：那种断言只钉漏斗本身——将来谁在调用点
+    /// 自己 `DownloadEngine::new`，它照旧全绿。这里数的是 `shared::constructions`，而记账卡在
+    /// `DownloadEngine::new` 这个卡口上（与谁造的无关），所以只要有一条路径另造引擎就会红。
+    ///
+    /// 三条路径：
+    /// 1. [`get`] 无 header = 内容库的 Modrinth 元数据 GET（走 `engine.download_bytes`）；
+    /// 2. [`get`] 带 header = CurseForge 那条（走 `engine.client()`，另一条机制）；
+    /// 3. `host::java::vendors` = Java 页渲染（走 `domestic()`，非 HTTP 的漏斗消费者）。
+    ///
+    /// 没走 `versions` 清单：它的地址是写死的 launchermeta，单测里要么打真网、要么吃满连接超时
+    /// —— 那正是「测试里不该发生的事」，所以选了同样真实但完全离线的三条。
+    #[test]
+    fn three_host_request_paths_share_one_engine() {
+        let dir = data_root("paths");
+        let env = HostEnv::at_root(&dir);
+        let cache_root = env.layout.cache();
+        let (url, counts) = loopback(2);
+
+        let without_headers = get(&env, &url, &[]).expect("Modrinth 元数据 GET");
+        let with_headers = get(&env, &url, &[("x-api-key", "test-key")]).expect("CF 带 header GET");
+        let vendors = crate::host::java::vendors(&env, &[]);
+
+        assert_eq!(
+            without_headers, with_headers,
+            "两条路径读的是同一份回环响应"
+        );
+        assert!(!vendors.is_empty(), "Java 页应有发行版行");
+        let (_, requests) = counts
+            .recv_timeout(Duration::from_secs(10))
+            .expect("回环服务应报告计数");
+        assert_eq!(requests, 2, "两条 HTTP 路径各发一条请求");
+        assert_eq!(
+            shared::constructions(&cache_root),
+            1,
+            "三条宿主请求路径必须共用同一个引擎（谁绕过漏斗另造一个，这条就红）"
+        );
+        std::fs::remove_dir_all(&dir).ok();
+    }
+}

crates/presenter/src/host/dispatch.rs

@@ -219,6 +219,12 @@ impl CoreHost {
             }
             AppCommand::SetSetting { key, value } => match settings::set(&self.env, &key, &value) {
                 Ok(()) => {
+                    // 「重新检测地区」：`settings::set` 已经删了 `region.json` 并让共享引擎失效，
+                    // 但自更新的 `Factory` 常驻持有旧引擎 —— 不在这条路径上重建它，自更新会继续
+                    // 按旧地区档案跑，直到重启（M165 复审 P2-1）。
+                    if key == super::engine::DETECT_REGION_ACTION {
+                        self.refresh_update_factory();
+                    }
                     self.send(CoreEvent::SettingsChanged(settings::groups(&self.env)));
                     self.java_chain.clear();
                     self.refresh_java();

crates/presenter/src/host/engine.rs

@@ -40,6 +40,14 @@ pub fn domestic(env: &HostEnv) -> bool {
     engine(env).region().is_domestic()
 }
 
+/// 「重新检测地区」这个动作键（设置页的行 id、`settings::set` 的分派、`dispatch` 里「要不要重建
+/// 自更新 Factory」的判断共用一个真相源）。
+///
+/// 动作不是普通设置：它要清 `region.json`、让 [`forget`] 失效共享引擎，并让自更新的 `Factory`
+/// 换引擎（M165 复审 P2-1）——所以三处都得认出它。常量放这里（引擎/地区这一侧），不放已经顶到
+/// 400 行红线的 `settings.rs`。
+pub(super) const DETECT_REGION_ACTION: &str = "download.action.detect_region";
+
 /// 设置里的 `java.vendorPriority`（空 = 按地区默认序）。
 pub fn java_priority(env: &HostEnv) -> Vec<JdkVendor> {
     env.store()

crates/presenter/src/host/settings.rs

@@ -136,7 +136,7 @@ fn download_group(env: &HostEnv) -> SettingGroupView {
             &text(env, "download.proxy_url"),
         ))
         .with(SettingRowView::action(
-            "download.action.detect_region",
+            super::engine::DETECT_REGION_ACTION,
             "重新检测地区",
             "清掉 24h 地区缓存，下次下载重新判定",
             "detect_region",
@@ -322,7 +322,7 @@ fn mcp_group(env: &HostEnv) -> SettingGroupView {
 ///
 /// 未知键、值类型不符、越界、落盘失败时返回用户可读文案。
 pub fn set(env: &HostEnv, key: &str, value: &str) -> Result<(), String> {
-    if key == "download.action.detect_region" {
+    if key == super::engine::DETECT_REGION_ACTION {
         return detect_region(env);
     }
     let parsed = parse_value(key, value)?;
@@ -370,10 +370,7 @@ fn parse_value(key: &str, value: &str) -> Result<Value, String> {
     }
 }
 
-/// 清掉 24h 地区缓存（下次建引擎重新判定）。
+/// 清掉 24h 地区缓存并让共享引擎失效（下次请求重新判定；自更新那份由 `dispatch` 重建 Factory）。
-///
-/// M165 起引擎是进程级共享的：光删 `region.json` 不够（下次请求根本不会重建引擎），
-/// 必须同时让共享登记处淘汰这一份，否则「重新检测地区」这句话在本次运行里不生效。
 fn detect_region(env: &HostEnv) -> Result<(), String> {
     let path = env.layout.cache().join("region.json");
     if path.is_file() {

crates/presenter/src/host/update_state.rs

@@ -66,6 +66,27 @@ impl Runtime {
         &self.view
     }
 
+    /// 重建「怎么造 Job」的装配（M165 复审 P2-1）。
+    ///
+    /// 自更新的 `Factory` 常驻持有下载引擎，`download::shared::forget` 换不掉它；「重新检测地区」
+    /// 要生效就得把新引擎接过来。只换 `factory`，**不动** `view` / `inflight` / 迁移收据：
+    /// 后台在飞的那条 Job 在派发时（`begin_check` / `begin_apply` → `Job`）就已经把 factory
+    /// 克隆进线程了，所以重建**不会**打断正在跑的检查/应用，只影响下一次派发。
+    pub fn rebuild_factory(&mut self, env: &HostEnv) {
+        self.factory = Factory::for_env(env);
+    }
+
+    /// 装配里那个下载引擎（单测断言「换了引擎」用；`Dir` 形态没有引擎）。
+    #[cfg(test)]
+    pub(super) fn factory_engine(
+        &self,
+    ) -> Option<&std::sync::Arc<unlucky_core::download::DownloadEngine>> {
+        match &self.factory {
+            Factory::Default { engine, .. } => Some(engine),
+            Factory::Dir { .. } => None,
+        }
+    }
+
     /// 当前快照（克隆给事件/线程）。
     #[must_use]
     pub fn snapshot(&self) -> UpdateView {
@@ -222,6 +243,15 @@ impl CoreHost {
         self.send(CoreEvent::Update(Box::new(view)));
     }
 
+    /// 让自更新子系统手里的引擎跟上共享登记处（M165 复审 P2-1）。
+    ///
+    /// 自更新的 `Factory` 从 `CoreHost::build` 起就把引擎存进字段，`shared::forget` 只让登记处
+    /// 不再持有那一份，换不掉它。所以「重新检测地区」除了失效登记处，还必须调本方法，否则自更新
+    /// 会继续按**旧地区档案**展开候选，直到进程结束。
+    pub(super) fn refresh_update_factory(&mut self) {
+        self.update.rebuild_factory(&self.env);
+    }
+
     /// 派一次检查（`manual` = 设置页点的「立即检查」；`false` = 启动时的静默检查）。
     pub(super) fn start_update_check(&mut self, manual: bool) {
         let Some(current) = self.update.current() else {

crates/presenter/src/host/update_tests.rs

@@ -17,6 +17,7 @@
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 
+use unlucky_core::download::region::{RegionMode, RegionProfile};
 use unlucky_core::download::verify::digest_bytes;
 use unlucky_core::download::HashAlgo;
 use unlucky_core::update::{Applied, Channel, Target, Version};
@@ -242,3 +243,93 @@ fn a_higher_version_without_our_platform_is_not_up_to_date() {
 mod apply;
 #[path = "update_session_tests.rs"]
 mod session;
+
+// ---------------------------------------------------------------- M165 复审 P2-1
+//
+// 这两条走的是**真实的命令路径**（`AppCommand::SetSetting` → `dispatch` → `settings::set`），
+// 不是直接调内部函数：要守的正是「动作路径上有没有把该做的事做全」。
+
+/// 「重新检测地区」之后，**自更新手里的引擎也要换**。
+///
+/// 自更新的 `Factory` 从 `CoreHost::build` 起就把引擎存在字段里（常驻到进程结束）；
+/// `download::shared::forget` 只让登记处不再持有那一份，**换不掉**它。于是只 forget 的话，
+/// 自更新会继续按**旧地区档案**展开候选，直到重启——M165 复审 P2-1 的那个洞。
+///
+/// 抓得住的变异：删掉 `host/dispatch.rs` 的 `SetSetting` 成功分支里那句
+/// `self.refresh_update_factory()` ⇒ 本用例红在 `Arc::ptr_eq`（Factory 还是淘汰前那一份）。
+#[test]
+fn detect_region_rebuilds_the_update_factory_engine() {
+    use std::sync::Arc;
+    use unlucky_core::download::shared;
+
+    let tmp = TempDir::new("region-refresh");
+    let env = HostEnv::at_root(tmp.path());
+    std::fs::create_dir_all(env.layout.cache()).expect("建缓存目录");
+    // 钉一份确定的地区档案：第一次构造不依赖本机时区/语言，断言才有确定的起点。
+    let region_path = env.layout.cache().join("region.json");
+    unlucky_core::download::region::store_cached(
+        &region_path,
+        &RegionProfile::pinned(RegionMode::Direct, unlucky_core::download::cache::now_ms()),
+    )
+    .expect("写 region.json");
+
+    let mut host = crate::host::CoreHost::headless(env.clone());
+    let cache_root = env.layout.cache();
+    assert_eq!(
+        shared::constructions(&cache_root),
+        1,
+        "装配时只该造一个引擎"
+    );
+    let before = host
+        .update
+        .factory_engine()
+        .expect("生产装配（Default）应有引擎")
+        .clone();
+    assert_eq!(before.region().mode, RegionMode::Direct);
+
+    host.dispatch_command(crate::dto::AppCommand::SetSetting {
+        key: "download.action.detect_region".to_string(),
+        value: String::new(),
+    });
+
+    let after = host
+        .update
+        .factory_engine()
+        .expect("重建后仍该有引擎")
+        .clone();
+    assert!(
+        !Arc::ptr_eq(&before, &after),
+        "「重新检测地区」必须换掉自更新用的引擎（否则它按旧地区档案跑到进程结束）"
+    );
+    assert!(
+        Arc::ptr_eq(&after, &crate::host::engine::engine(&env)),
+        "自更新必须指向登记处的当前引擎，而不是被淘汰的那一份"
+    );
+    assert_eq!(
+        shared::constructions(&cache_root),
+        2,
+        "淘汰一次 = 多构造一次（既不多也不少）"
+    );
+}
+
+/// 重建 `Factory` **不打断**在飞的检查/应用：在跑的那条 `Job` 派发时就已经把装配克隆走了。
+#[test]
+fn rebuilding_the_factory_does_not_touch_a_running_job() {
+    let tmp = TempDir::new("factory-rebuild");
+    dir_source(&tmp, &manifest_for("0.9.0", b"new", "notes"), b"new");
+    let env = HostEnv::at_root(tmp.path());
+    let mut runtime = Runtime::with_factory(&env, factory(&tmp));
+
+    // 派发一条（模拟「正在查」），再重建装配：
+    let job = runtime.begin_check(true).expect("应能派发");
+    assert!(runtime.inflight());
+    runtime.rebuild_factory(&env);
+    assert!(runtime.inflight(), "重建装配不该清掉在飞标记");
+    assert!(
+        matches!(runtime.view().outcome, UpdateOutcome::Checking),
+        "重建装配不该改状态快照"
+    );
+    // 在飞那条 Job 仍然可用（它拿着自己那份装配），能正常跑完并回报。
+    let outcome = outcome_of(job.check(&version("0.2.2"), Channel::Stable));
+    assert_eq!(outcome.as_str(), "available");
+}