@@ -806,3 +806,61 @@ mcpp 下限跨过 B1 的发布**,而不是「B1 合入了」。这是一条发
 2. ⚠️ **「正确的 soname 就一定赢」**(§5.3 末)—— 取决于 `$ORIGIN` 与依赖包
    `runtime_search_dirs` 在 `link_line::UnitTail` 里的相对次序,与 **#304** 合流。
    两条都**不要写进设计当结论**,它们是待测项。
+
+---
+
+## 13. 真实验证:用生态自己的 glib 复现 issue §2
+
+⚠️ 本节是**实测**,不是设计。用的是 `mcpplibs/mcpp-index#245`(eui-neo 的 Linux SNI
+托盘)的需求场景 —— 但**不依赖宿主**:暂存的 glib 及其整条闭包全部取自 xim
+(`xim:glib@2.80.0` / `zlib` / `pcre2` / `libselinux` / `util-linux` / `libffi`),
+引擎里没有任何 glib / zlib / 托盘的知识。
+
+### 13.1 场景
+
+`libgio-2.0.so.0` 的 `DT_NEEDED` 里有 `libz.so.1`(实测,不是构造出来的),
+而索引里 `compat.zlib` 是 `kind = "lib"`。一个同时依赖两者的工程 = issue §2。
+
+### 13.2 读数
+
+```console
+$ mcpp build
+warning: trayapp: 88 symbols in this image are also provided by a library it loads.
+    adler32()  adler32_combine()  ...  and 82 more
+  Also provided by:
+    …/xpkgs/xim-x-zlib/1.3.1/lib/libz.so.1.3.1
+```
+
+| | issue §2 报的 | 本次实测 |
+|---|---|---|
+| exe 里 DEFINED 的 zlib 符号 | 86 | **88** |
+| `LD_DEBUG=bindings` 中 libgio 绑到 exe | 12 次 | 同形状,**含 `inflateGetHeader' [ZLIB_1.2.2]`** —— 带版本的引用绑到无版本的定义 |
+| 有没有任何工具说话 | **没有** | **mcpp 在构建期指名了两个提供者** |
+
+⭐ issue 里那条「同一情形在链接期(跨 `.so` 时)是硬错误,在这里静默通过」
+现在有了构建期的声音。
+
+### 13.3 ⚠️⚠️ 出路的次序被这次实测改掉了
+
+按 `linkage = "shared"` 走一遍:
+
+| | 之前 | 之后 |
+|---|---|---|
+| exe 导出的 zlib 符号 | 88 | **0** |
+| 诊断 | 报 | 静默 |
+| **进程里加载的 zlib** | **1 份** | ⚠️ **2 份**(`libzlib.so` + `libz.so.1`) |
+
+`readelf -d bin/libzlib.so | grep SONAME` → **没有**。这正是 §5.3 推导出的结果,
+现在是实测:**这根轴单独用,会把一个可检测的缺陷换成一个不可检测的缺陷。**
+
+⇒ 诊断文案里三条出路的**次序**因此改了:第一条必须是永远正确的那条
+(让一方不再提供),形态切换排最后并写清它的前提。单测断言的是**次序**,
+不是三个子串都在。
+
+### 13.4 这次验证证明了什么
+
+1. 引擎在**真实 ELF 闭包**上工作(glib/gio + zlib/pcre2/selinux/mount/ffi),
+   不只是在人造 fixture 上;
+2. 两段式谓词在真实图上**没有误报**(vendor 包自身的 `.so` 之间不报);
+3. `dependency_linkage` 的逃生口在真实图上**确实生效**(88 → 0);
+4. ⚠️ 而它的**局限也是真的**,并因此改了文案 —— 这是本次验证最有价值的产出。
@@ -278,10 +278,19 @@ An arrangement with one copy in the process is silent. The verdict is recorded
 in `target/<triple>/<fp>/resolution.json` under `runtime.symbol_provision`,
 with the count and its denominator, so CI can read it without `readelf`.
 
-It is a warning by default and an error under `--strict`. Ways out, in the
-order they usually apply: give the duplicated package a single form with
-`dependency_linkage`; stop one side from providing the library; or give both
-the same `soname` so they resolve to one file.
+It is a warning by default and an error under `--strict`. The ways out are
+ordered, and the order matters:
+
+1. **Stop one side from providing it** — usually a package shipping a copy of a
+   library the graph already builds. Always correct.
+2. **Make both resolve to one file** by declaring the library's real `soname`
+   on its target.
+3. **`dependency_linkage`** changes which form mcpp builds. It removes *this*
+   finding, but on its own it can leave **two** copies loaded instead of one:
+   measured on a graph staging glib (whose `libgio` needs `libz.so.1`) beside a
+   statically built `compat.zlib`, switching the form dropped the executable's
+   88 exported symbols and then loaded both `libzlib.so` and `libz.so.1`. It
+   unifies the two providers only when (2) holds as well.
 
 `private_include_dirs` names the entries **of `include_dirs`** that stop at this
 package's own boundary: this package compiles with them, and a consumer never
 
@@ -251,9 +251,16 @@ dependency_linkage = "shared"        # 按 profile 覆盖
 `target/<triple>/<fp>/resolution.json` 的 `runtime.symbol_provision` 下,带计数
 与分母,CI 不需要 `readelf` 就能读。
 
-默认是警告,`--strict` 下升级为错误。三条出路,按通常适用的顺序:用
-`dependency_linkage` 给重复的包一个统一形态;让其中一方不再提供这个库;或者给
-两者相同的 `soname`,让它们解析到同一个文件。
+默认是警告,`--strict` 下升级为错误。三条出路**有次序**,而次序是要紧的:
+
+1. **让其中一方不再提供这个库** —— 通常是那个携带了依赖图已经在构建的库的副本
+   的包。永远正确。
+2. **让两者解析到同一个文件**:在库的 target 上声明它真正的 `soname`。
+3. **`dependency_linkage`** 改变 mcpp 构建的形态。它会消掉**这一条**报告,但单
+   独用可能把一份变成**两份**:实测在一个暂存了 glib(其 `libgio` 需要
+   `libz.so.1`)、同时静态构建 `compat.zlib` 的图上,切换形态让可执行文件的 88
+   个导出符号归零,然后 `libzlib.so` 与 `libz.so.1` **两个都被加载**。只有在
+   (2) 同时成立时它才真的把两个提供者合成一个。
 
 `private_include_dirs` 指出 **`include_dirs` 中**在本包边界处停住的那些条目:
 本包用它们编译,消费者永远收不到。
 
@@ -224,19 +224,34 @@ std::string Report::explain(std::string_view artifact) const {
     body += "  Also provided by:\n";
     for (auto const& label : providers) body += std::format("    {}\n", label);
 
-    // WHY it matters, in the terms the reader can check, then what to do. The
-    // three ways out are not alternatives to taste: the first changes which
-    // form mcpp builds, the second removes a provider, the third makes the two
-    // providers the same file.
+    // WHY it matters, then what to do — IN THE ORDER THAT ACTUALLY WORKS.
+    //
+    // ⚠️ `dependency_linkage = "shared"` is deliberately NOT first, and that
+    // ordering was corrected against a measurement rather than reasoned. On a
+    // real graph (a package staging glib, whose libgio pulls libz.so.1, plus a
+    // statically built compat.zlib) switching the form does remove the
+    // executable's 88 exported symbols — and then TWO zlibs load, because the
+    // library mcpp builds is `libzlib.so` while the reference is to
+    // `libz.so.1`. That is a worse state than the one being reported: two
+    // copies instead of one, and no diagnostic at all, since the check
+    // described above only looks at executables.
+    //
+    // So the first suggestion is the one that is always correct, and the form
+    // switch is offered with the condition that makes it work.
     body +=
         "  The executable is searched first, so the copy inside it wins for\n"
         "  every symbol both provide — the library's own copy is never called,\n"
         "  and code inside that library now runs against a build it was not\n"
         "  linked against.\n"
-        "  Ways out: give the duplicated package a single form with\n"
-        "  `[build] dependency_linkage` or a per-dependency `linkage`; stop one\n"
-        "  side from providing it; or give both the same SONAME so they resolve\n"
-        "  to one file.";
+        "  Ways out, in the order they apply:\n"
+        "    1. stop one side from providing it — usually the package that\n"
+        "       ships a copy of a library the graph already builds;\n"
+        "    2. make both resolve to ONE file: declare the library's real\n"
+        "       SONAME on its target, so the shared copy and the built one are\n"
+        "       the same name;\n"
+        "    3. `[build] dependency_linkage` / a per-dependency `linkage`\n"
+        "       changes which form mcpp builds — it removes THIS finding, but\n"
+        "       it only unifies the two providers when (2) holds as well.";
     return body;
 }
 
 
@@ -145,9 +145,17 @@ TEST(SymbolProvision, TheReportNamesEveryProviderAndCapsTheSymbolList) {
     EXPECT_NE(text.find("20 symbols"), std::string::npos);
     EXPECT_NE(text.find("and 14 more"), std::string::npos);
     EXPECT_NE(text.find("/pkg/lib/libz.so.1"), std::string::npos);
-    // The three ways out are the point of the message.
-    EXPECT_NE(text.find("dependency_linkage"), std::string::npos);
-    EXPECT_NE(text.find("SONAME"), std::string::npos);
+    // The three ways out are the point of the message, and their ORDER is
+    // load-bearing: switching the form removes this finding while leaving two
+    // copies loaded unless the SONAMEs also match, so it must not be first.
+    auto stop = text.find("stop one side");
+    auto soname = text.find("SONAME");
+    auto form = text.find("dependency_linkage");
+    ASSERT_NE(stop, std::string::npos);
+    ASSERT_NE(soname, std::string::npos);
+    ASSERT_NE(form, std::string::npos);
+    EXPECT_LT(stop, soname);
+    EXPECT_LT(soname, form);
 }
 
 TEST(SymbolProvision, OnlyAConflictIsActionable) {