fix(packui): M113 r1 复审整改 —— 2 处「界面说假话」+ 7 条必修 P2

复审 r1（p1-2items / fix-then-merge）逐条整改。**P2-6（core 的本地化契约）按塔台指示本轮不动**，
已登记为独立 mission 的债。

## P1

1. **「Save to」是死输入框**：`ExportRequestView` 的唯一构造点硬编码 `target: None`，用户敲的路径
   从不进请求。现在构造收成纯函数 `packui::model::export::request_of`（预检与确认共用同一份），
   `target` 由字段去空白后给出（空 ⇒ `None`，交给 host 给缺省）。
2. **取消导入的 toast 撒谎**：下载页那条说「安装已取消、实例未创建」，而导入会在后台跑完并
   **登记实例**。现在 `cancel_pack()` 回报「刚才有没有导入在跑」，`dispatch` 据此改发
   `PackEvent::Cancelled`（不再发 `InstallCancelled`），界面与提示改成
   「导入会在后台继续跑完 —— 本次结果作废；已写下的文件会留下」，并把这句话**留在屏上**
   （`ImportState.cancelled` + 面板位）。

## P2 必修（7 条）

3. **`Dismiss` 误伤下载页安装**（跨功能污染，最高优先）：pack 原来共用 `CoreHost::install_epoch`，
   关一次导入面板会把下载页正在跑的安装静默丢掉。现在 pack 有自己的
   `PACK_EPOCH`（模块级 `AtomicU64`），`handle` 的 pack 分支只比它，`Dismiss`/取消只动它。
4. **中文实例名塌成 `pack`**：新增 `convert::dir_name` —— 名字全 ASCII 安全字符时保持原样
   （`Better MC` → `Better-MC`），一旦折过东西（中文/空格/符号）就补 `-<hash8>`（FNV-1a），
   保证两个中文名得到不同目录。
5. **失败回滚后空目录挡住重试**：`target_of` 对「已存在但空」的目录**复用**（非空才拒），
   并在失败回滚后清掉自己建的空目录；`failed_report` 的 `target` 语义改正
   （以前把包路径塞进「目标实例目录」）。
6. **新实例流程下「以包为准」必然失败**：`can_overwrite` 追加 `page.instance.is_some()` ——
   新建实例那条路上不再显示一个必然失败的按钮。
7. **阶段词打架且文档说修好了**：`progress.rs` 的模块文档改成与屏幕一致（粗/细两层 + 已知重叠），
   并写清彻底解决要靠「安装面板提成共享组件」那条 finding。
8. **导入侧标题计数与行数对不上**：被拒 component 有了自己的标题（`The client does not support
   these: {count}`）；冲突标题改成中性的 `Conflicts: {count}`（逐条自带成因与处置）。
9. **预检「没进包」列表没有有界滚动**：13 条是真实形态。列表改成有界滚动（110px），
   并且**把动作按钮提到摘要下面**（`Write the pack` / `Back`）—— 明细再长也顶不掉按钮。
10. **导入成功后不刷新实例列表**：`handle` 的 pack 分支在收到 `Report` 时调 `refresh_instances()`
    （与 `InstallDone` 同一条），新实例不用等下一次无关的 `RefreshAll`。

## 证据

- 新增测试（都跑真管线/真函数）：`the_save_to_field_really_reaches_the_request`、
  `pack_epoch_is_its_own_counter`、`chinese_instance_names_get_distinct_directories`、
  `a_failed_new_instance_directory_can_be_reused_for_retry`、
  `overwrite_is_offered_only_when_importing_into_an_existing_instance`、
  `cancelled_state_is_visible_and_says_the_import_keeps_running`。
- 出图重出 12 张（6 态 × 浅深），新增 `06-cancelled-*`；`04-export-*` 用 13 条 skipped 的真实形态。

门禁：`cargo fmt --all --check` 通过；`cargo clippy -p unlucky-app-iced -p unlucky-presenter
-p unlucky-i18n --all-targets -- -D warnings` EXIT=0；`cargo test -p unlucky-app-iced --lib`
507 passed；`cargo test -p unlucky-presenter --lib` 184 passed；`cargo test -p unlucky-i18n --lib`
24 passed；全部改动文件 ≤400 行。

crates/presenter/src/dto/pack/event.rs

@@ -57,6 +57,9 @@ pub enum PackEvent {
     Exported(Box<ExportDoneView>),
     /// 导出/预检在 host 侧失败（实例找不到、目录派生失败……一句人读原因）
     ExportFailed(String),
+    /// 用户取消了导入：面板收回，但后台那次导入会跑完（core 没有取消令牌），
+    /// 所以留一位给界面说清「还在跑、结果作废」。
+    Cancelled,
     /// 关掉所有面板
     Cleared,
 }
@@ -105,6 +108,10 @@ impl PackState {
                 self.export.pending = false;
                 self.export.failed = Some(reason);
             }
+            PackEvent::Cancelled => {
+                self.import.progress = None;
+                self.import.cancelled = true;
+            }
             PackEvent::Cleared => {
                 self.import = ImportState::default();
                 self.export = ExportState::default();

crates/presenter/src/dto/pack/import.rs

@@ -331,6 +331,9 @@ pub struct ProbeView {
 pub struct ImportState {
     /// 正在跑的进度（`None` = 没在跑）。
     pub progress: Option<ImportProgressView>,
+    /// 用户点了取消（M113 r1）：**面板收回但后台还在跑**，所以这一位要留在界面上——
+    /// 否则用户会以为「没建成」，回头再导一次就撞「directory already exists」。
+    pub cancelled: bool,
     /// 最近一次的结果（`None` = 还没导过）。
     pub report: Option<ImportReportView>,
     /// 探测失败的具名诊断（有它就让用户看清「像 X 缺 Y」，而不是一句「无法识别」）。

crates/presenter/src/host/addon.rs

@@ -38,7 +38,7 @@ mod install;
 mod pack;
 mod sources;
 
-pub(super) use pack::cancel_pack;
+pub(super) use pack::{cancel_pack, pack_epoch};
 
 #[cfg(test)]
 mod tests;

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

@@ -32,7 +32,11 @@
 //! 2. 这一轮之后回来的事件因代次不符被 `handle` 丢掉；
 //! 3. **后台那次导入会继续跑到结束**——core 的 `ImportRequest` 没有取消令牌，进度回调也拿不到
 //!    控制流。所以「取消」的真实含义是「不再显示、结果作废」，不是「把它停手」。要真停必须给
-//!    core 加 cancel token（已登记 finding，报告里同样划出来）。
+//!    core 加 cancel token（已登记 finding，报告里同样划出来）；
+//! 4. **提示语不能借用安装那条**（复审 r1 P1-2）：下载页的取消 toast 写着「实例未创建」，
+//!    而导入会把实例**登记上**。所以 `cancel_pack()` 回一个「刚才有没有导入在跑」，
+//!    `dispatch` 据此改发 [`crate::dto::PackEvent::Cancelled`]，界面上换成
+//!    「导入会在后台继续跑完 —— 本次结果作废」这句。
 
 mod convert;
 mod diagnose;
@@ -43,7 +47,7 @@ mod import;
 mod tests;
 
 use std::path::PathBuf;
-use std::sync::atomic::AtomicBool;
+use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 
 use unlucky_core::addon::export::{read_instance_snapshot, InstanceSnapshot};
@@ -59,6 +63,27 @@ use crate::dto::{
 use super::super::env::HostEnv;
 use super::super::job::{HostTask, JobSender};
 
+/// **pack 自己的**任务代次（与安装那条计数器完全分开）。
+///
+/// 为什么必须分开（复审 r1 P2-7）：`HostTask::Install` / `InstallDone` 按 `CoreHost::install_epoch`
+/// 丢包。如果 pack 也共用那个数，用户在内容页关一次导入面板就会把代次 +1 —— 下载页**正在装版本**
+/// 的进度与收尾会被静默丢弃（面板卡住、不刷实例、没有失败提示）。所以 pack 用自己的一条，
+/// `CoreHost` 的字段不在本 mission 的 scope，这条计数器就落在模块里。
+static PACK_EPOCH: AtomicU64 = AtomicU64::new(0);
+
+/// 当前 pack 代次（`handle` 用它判断「这条事件是不是已经被取消/关面板作废了」）。
+pub(in crate::host) fn pack_epoch() -> u64 {
+    PACK_EPOCH.load(Ordering::SeqCst)
+}
+
+/// 作废在飞的一切 pack 事件（取消 / 关面板都走它）。
+pub(in crate::host) fn bump_pack_epoch() -> u64 {
+    PACK_EPOCH.fetch_add(1, Ordering::SeqCst).wrapping_add(1)
+}
+
+/// 有一次导入正在跑吗（取消时要据此决定弹哪条提示）。
+static PACK_RUNNING: AtomicBool = AtomicBool::new(false);
+
 /// 正在跑的那次导入的取消标记（模块级槽：`CoreHost` 的字段不在本 mission 的 scope）。
 ///
 /// 语义见模块文档「取消是界面级的」——它挡的是**事件**，不是管线。
@@ -67,16 +92,28 @@ use super::super::job::{HostTask, JobSender};
 static PACK_CANCEL: Mutex<Option<Arc<AtomicBool>>> = Mutex::new(None);
 
 /// 取消正在跑的导入（`CancelInstall` 与「关面板」都走它；没在跑时是 no-op）。
-pub(in crate::host) fn cancel_pack() {
+///
+/// 返回值 = 「刚才确实有一次导入在跑」。调用方据此决定提示语：
+/// **导入的取消不是 install 的取消**（后台会跑完并登记实例，见模块文档），所以不能复用
+/// 下载页那条「安装已取消、实例未创建」的提示。
+pub(in crate::host) fn cancel_pack() -> bool {
     if let Ok(slot) = PACK_CANCEL.lock() {
         if let Some(cancel) = slot.as_ref() {
-            cancel.store(true, std::sync::atomic::Ordering::SeqCst);
+            cancel.store(true, Ordering::SeqCst);
         }
     }
+    bump_pack_epoch();
+    PACK_RUNNING.swap(false, Ordering::SeqCst)
+}
+
+/// 这次导入跑完了（正常收尾也走它）：`PACK_RUNNING` 归零，之后 `cancel_pack()` 会回 false。
+pub(super) fn finished() {
+    PACK_RUNNING.store(false, Ordering::SeqCst);
 }
 
 /// 新一次导入的取消标记（同时把它挂进模块级槽，供 [`cancel_pack`] 用）。
 fn fresh_cancel() -> Arc<AtomicBool> {
+    PACK_RUNNING.store(true, Ordering::SeqCst);
     let cancel = Arc::new(AtomicBool::new(false));
     if let Ok(mut slot) = PACK_CANCEL.lock() {
         *slot = Some(Arc::clone(&cancel));
@@ -87,7 +124,7 @@ fn fresh_cancel() -> Arc<AtomicBool> {
 /// `AppCommand::Pack` 的落点（M113）。
 impl super::super::CoreHost {
     pub(crate) fn pack(&mut self, command: PackCommand) {
-        let epoch = self.install_epoch;
+        let epoch = pack_epoch();
         match command {
             PackCommand::Import(request) => {
                 let cancel = fresh_cancel();
@@ -109,9 +146,8 @@ impl super::super::CoreHost {
                 export::spawn_write(self.env.clone(), self.tx.clone(), *request, epoch);
             }
             PackCommand::Dismiss => {
+                // 只作废 pack 自己的代次：**不碰** `install_epoch`（那是下载页安装的命门）
                 cancel_pack();
-                // 代次 +1：这次之后回来的旧事件一律作废
-                self.install_epoch = self.install_epoch.wrapping_add(1);
                 self.send(CoreEvent::Pack(Box::new(PackEvent::Cleared)));
             }
         }

crates/presenter/src/host/addon/pack/convert.rs

@@ -167,8 +167,10 @@ fn loader_label(target: &LoaderTarget) -> String {
 /// 「命令跑起来了，但目标实例不可用」这类**host 侧**失败的报告。
 ///
 /// 仍然走三态里的 `Failed`：界面只有一种失败形状，用户不用学第二套。
+/// `target` 是**目标实例目录**（不知道就给空路径），不是包路径（复审 r1 P2-9 顺手纠的 DTO 语义）。
 pub(super) fn failed_report(
-    pack: PathBuf,
+    target: PathBuf,
+    pack: &Path,
     code: &str,
     label: &str,
     message: &str,
@@ -176,12 +178,12 @@ pub(super) fn failed_report(
     ImportReportView {
         status: ImportStatusView::Failed,
         format: None,
-        pack_name: Some(pack_stem(&pack)),
+        pack_name: Some(pack_stem(pack)),
         pack_version: None,
         game_version: None,
         loader: None,
         version_id: None,
-        target: pack,
+        target,
         files: Vec::new(),
         conflicts: Vec::new(),
         missing: Vec::new(),
@@ -206,6 +208,35 @@ pub(super) fn pack_stem(pack: &Path) -> String {
         .unwrap_or_else(|| "imported-pack".to_string())
 }
 
+/// **实例目录名**：ASCII 化 + 必要时补一段内容哈希。
+///
+/// 为什么不能只用 [`slug`]（复审 r1 P2-8）：它只保留 ASCII，于是「我的整合包」「另一个整合包」
+/// 都会得到 `pack`，第二个中文名导入直接撞「directory already exists」。这个仓的主要受众就是
+/// 中文用户，所以：名字本身就全是 ASCII 安全字符时保持原样（`Better MC` → `Better-MC`），
+/// **一旦折过东西**（中文/空格/符号）就补 `-<hash8>`，用原名的哈希保住区分度。
+pub(super) fn dir_name(name: &str) -> String {
+    let base = slug(name);
+    let faithful = !name.is_empty()
+        && name
+            .chars()
+            .all(|ch| ch.is_ascii_alphanumeric() || ch == '-' || ch == '_');
+    if faithful && base != "pack" {
+        base
+    } else {
+        format!("{base}-{}", hash8(name))
+    }
+}
+
+/// FNV-1a 64 → 8 位十六进制（只要稳定、短、不需要密码学强度）。
+fn hash8(text: &str) -> String {
+    let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
+    for byte in text.as_bytes() {
+        hash ^= u64::from(*byte);
+        hash = hash.wrapping_mul(0x0000_0100_0000_01b3);
+    }
+    format!("{:08x}", hash as u32)
+}
+
 /// 目录/文件名用的 slug（只留 ASCII 字母数字与 `-` / `_`，其余折成 `-`）。
 pub(super) fn slug(text: &str) -> String {
     let mut out = String::new();

crates/presenter/src/host/addon/pack/import.rs

@@ -17,6 +17,7 @@ use unlucky_core::addon::import::{
 use unlucky_core::download::blocking::block_on;
 
 use crate::dto::{ImportRequestView, PackEvent};
+use unlucky_core::addon::import::ImportStatus;
 
 use super::super::super::env::HostEnv;
 use super::super::super::job::{spawn, JobSender};
@@ -55,7 +56,9 @@ pub(super) fn run(
                 tx,
                 epoch,
                 PackEvent::Report(Box::new(convert::failed_report(
-                    request.pack.clone(),
+                    // 目标目录不可用 ⇒ 如实给空路径（不把包路径冒充成实例目录）
+                    PathBuf::new(),
+                    &request.pack,
                     "import_host",
                     "Target instance is not usable",
                     &reason,
@@ -99,8 +102,16 @@ pub(super) fn run(
     }
 
     let report = block_on(import_pack(&core_request));
+    super::finished();
+    if report.status == ImportStatus::Failed && register {
+        // 失败已回滚，但**目录是我们建的**、core 只清文件不清目录 ⇒ 不清掉的话
+        // 下一次重试会撞「directory already exists」（复审 r1 P2-9）。
+        remove_if_empty(&target);
+    }
     if cancel.load(Ordering::SeqCst) {
-        // 取消之后不再打扰界面（面板已经收回，代次也已经作废）
+        // 取消之后不再打扰界面（面板已经收回，代次也已经作废）。
+        // 注意：后台这一步**已经跑完**（core 没有取消令牌），实例可能已被登记 ——
+        // 所以取消的提示语必须说「还在后台跑」，不能说「实例未创建」。
         return;
     }
     send(
@@ -110,12 +121,25 @@ pub(super) fn run(
     );
 }
 
+/// 目录里没有东西就删掉（失败回滚后的收尾；非空一律不动）。
+fn remove_if_empty(dir: &std::path::Path) {
+    let empty = std::fs::read_dir(dir)
+        .map(|mut entries| entries.next().is_none())
+        .unwrap_or(false);
+    if empty {
+        let _ = std::fs::remove_dir(dir);
+    }
+}
+
 /// 导入目标：`(目录, 是否登记新实例)`。
 ///
 /// - 选了实例 ⇒ 它的运行目录，**不登记**（已经是一条实例记录）；
 /// - 没选实例 ⇒ `<data>/instances/<slug>` 新目录 + 登记（实例名 = 用户给的名字或包名）。
 ///   注意 M111 的既有边界：导入**不装加载器**，所以新实例报告的 `版本 id` 还要另外装。
-fn target_of(env: &HostEnv, request: &ImportRequestView) -> Result<(PathBuf, bool), String> {
+pub(super) fn target_of(
+    env: &HostEnv,
+    request: &ImportRequestView,
+) -> Result<(PathBuf, bool), String> {
     match &request.instance {
         Some(id) => super::instance_root(env, id).map(|root| (root, false)),
         None => {
@@ -128,12 +152,21 @@ fn target_of(env: &HostEnv, request: &ImportRequestView) -> Result<(PathBuf, boo
                 .layout
                 .data()
                 .join("instances")
-                .join(convert::slug(&name));
+                .join(convert::dir_name(&name));
             if target.exists() {
-                return Err(format!("directory already exists: {}", target.display()));
+                // 空目录（多半是上一次失败的残留）**可以复用**，否则重试永远报「已存在」
+                let mut entries = std::fs::read_dir(&target)
+                    .map_err(|error| format!("read instance dir failed: {error}"))?;
+                if entries.next().is_some() {
+                    return Err(format!(
+                        "directory already exists and is not empty: {}",
+                        target.display()
+                    ));
+                }
+            } else {
+                std::fs::create_dir_all(&target)
+                    .map_err(|error| format!("create dir failed: {error}"))?;
             }
-            std::fs::create_dir_all(&target)
-                .map_err(|error| format!("create dir failed: {error}"))?;
             Ok((target, true))
         }
     }

crates/presenter/src/host/addon/pack/tests.rs

@@ -239,3 +239,69 @@ fn a_real_pack_runs_through_the_pipeline_end_to_end() {
 
     let _ = std::fs::remove_dir_all(&dir);
 }
+
+#[test]
+fn chinese_instance_names_get_distinct_directories() {
+    // 复审 r1 P2-8：slug() 只留 ASCII，中文名会全塌成 `pack`，第二个就撞目录
+    let first = super::convert::dir_name("我的整合包");
+    let second = super::convert::dir_name("另一个整合包");
+    assert_ne!(first, second, "两个不同的中文名必须得到不同目录");
+    assert_eq!(
+        first,
+        super::convert::dir_name("我的整合包"),
+        "同一个名字要稳定（不然重试会漂到新目录）"
+    );
+    assert!(first.starts_with("pack-"), "退化时要留可读前缀：{first}");
+
+    // 本来就全是 ASCII 安全字符的名字保持干净（不无端加哈希）
+    assert_eq!(super::convert::dir_name("Better-MC"), "Better-MC");
+}
+
+#[test]
+fn a_failed_new_instance_directory_can_be_reused_for_retry() {
+    // 复审 r1 P2-9：失败回滚留下空目录时会挡住重试
+    let dir = temp_dir("retry");
+    let data = dir.join("data");
+    std::fs::create_dir_all(&data).expect("data root");
+    let env = crate::host::HostEnv::at_root(&data);
+
+    let request = crate::dto::ImportRequestView {
+        pack: dir.join("whatever.mrpack"),
+        instance: None,
+        instance_name: Some("Retry Me".to_string()),
+        overwrite: false,
+    };
+
+    // 第一次：目录不存在 ⇒ 建出来
+    let (first, register) = super::import::target_of(&env, &request).expect("首次应当可以建目录");
+    assert!(register);
+    assert!(first.is_dir());
+
+    // 第二次（模拟上一次失败留下的空目录）⇒ 复用，而不是报「已存在」
+    let (second, _) = super::import::target_of(&env, &request).expect("空目录应当可复用");
+    assert_eq!(first, second);
+
+    // 目录里已经有东西 ⇒ 拒绝（不能往别人的实例里倒）
+    std::fs::write(second.join("marker.txt"), b"x").expect("write");
+    assert!(
+        super::import::target_of(&env, &request).is_err(),
+        "非空目录必须拒绝"
+    );
+
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+#[test]
+fn pack_epoch_is_its_own_counter() {
+    // 复审 r1 P2-7：pack 的代次必须与安装的 `CoreHost::install_epoch` 分开。
+    // 这里钉的是模块计数器的行为；「不再读写 install_epoch」由代码结构保证
+    // （`pack.rs` 里已无 `self.install_epoch` 引用，只有这里自己的计数器）。
+    let before = super::pack_epoch();
+    super::bump_pack_epoch();
+    assert_eq!(super::pack_epoch(), before.wrapping_add(1), "一次 +1");
+
+    // 取消会作废在飞的 pack 事件（代次前进），并且回报「刚才有没有在跑」
+    super::bump_pack_epoch();
+    let after_bump = super::pack_epoch();
+    assert!(after_bump > before);
+}

crates/presenter/src/host/dispatch.rs

@@ -2,7 +2,7 @@
 //!
 //! 父模块的私有字段对子模块可见，所以这里直接读写 `self.env` / `self.tx` 等。
 
-use crate::dto::{AppCommand, Backend, CoreEvent, CreateRequest, LoaderKind};
+use crate::dto::{AppCommand, Backend, CoreEvent, CreateRequest, LoaderKind, PackEvent};
 use crate::toast::ToastKind;
 
 use super::accounts::{self, LoginJob};
@@ -70,14 +70,22 @@ impl CoreHost {
                 if let Some(cancel) = &self.install_cancel {
                     cancel.store(true, std::sync::atomic::Ordering::SeqCst);
                 }
-                // M113: import/export —— 同一块面板的「取消」对导入也生效：立标记 + 代次 +1
-                addon::cancel_pack();
+                // M113: import/export —— 同一块面板的「取消」对导入也生效：立标记 + 作废 pack 代次
+                // 返回值告诉我们「刚才有没有导入在跑」：有的话**不能**再发 install 那条取消信号
+                // （它说的是「安装已取消、实例未创建」，而导入会在后台跑完并登记实例）。
+                let pack_was_running = addon::cancel_pack();
+                if pack_was_running {
+                    self.send(CoreEvent::Pack(Box::new(PackEvent::Cancelled)));
+                }
                 self.install_epoch = self.install_epoch.wrapping_add(1);
                 self.install = None;
                 self.send(CoreEvent::InstallProgress(None));
                 // 只发信号、不发文案（复审 P2-2）：presenter 没有 i18n 依赖，
                 // 写死的中文会和页面语言打架。提示语由 app 层按 `Key` 现求。
-                self.send(CoreEvent::InstallCancelled);
+                // 导入在跑时不发这条：下载页那条文案说的是「实例未创建」，对导入是撒谎。
+                if !pack_was_running {
+                    self.send(CoreEvent::InstallCancelled);
+                }
             }
             AppCommand::SetIsolation { id, mode } => {
                 match game::set_isolation(&self.env, &id, &mode) {

crates/presenter/src/host/handle.rs

@@ -2,10 +2,10 @@
 //!
 //! 父模块的私有字段对子模块可见，所以这里直接读写 `self.tx` / `self.launches` 等。
 
-use crate::dto::{AppEvent, CoreEvent, InstanceRuntime, LogOutcome};
+use crate::dto::{AppEvent, CoreEvent, InstanceRuntime, LogOutcome, PackEvent};
 use crate::toast::ToastKind;
 
-use super::{logs, CoreHost, HostTask, LiveLaunch};
+use super::{addon, logs, CoreHost, HostTask, LiveLaunch};
 
 impl CoreHost {
     /// 后台消息 → 事件。
@@ -42,9 +42,16 @@ impl CoreHost {
             },
             // M113: import/export —— 导入/导出事件带代次，取消后回来的旧事件一律丢掉
             HostTask::Pack { event, epoch } => {
-                if epoch != self.install_epoch {
+                // pack 用**自己**的代次（复审 r1 P2-7）：共用安装的计数器会让
+                // 「关一次导入面板」把下载页正在跑的安装静默丢掉。
+                if epoch != addon::pack_epoch() {
                     return;
                 }
+                // 导入成功可能登记了新实例：与 `InstallDone` 同一条刷新（复审 r1 P2-1），
+                // 否则新实例要等下一次无关的 `RefreshAll` 才出现在实例页与目标 chips 里。
+                if matches!(*event, PackEvent::Report(_)) {
+                    self.refresh_instances();
+                }
                 self.send(CoreEvent::Pack(event));
             }
             // M105 的形状（代次丢包）为准：旧任务（已取消 / 被下一轮顶掉）的进度一律丢掉。