diff --git a/plugins/dsh-mail-bridge/test/persisted-cwd-not-found.test.mjs b/plugins/dsh-mail-bridge/test/persisted-cwd-not-found.test.mjs
index 03c73a9..023b4c4 100644
--- a/plugins/dsh-mail-bridge/test/persisted-cwd-not-found.test.mjs
+++ b/plugins/dsh-mail-bridge/test/persisted-cwd-not-found.test.mjs
@@ -73,8 +73,64 @@ function orderHolds(src) {
   return at >= 0 && th > at;
 }
 
-/** 判据整体：既要区分，也要顺序对 */
-const criterionPasses = src => distinguishes(src) && orderHolds(src);
+/**
+ * 取 `catch (...) { … }` 的**内层正文**（花括号配对，不会误取到函数体）。
+ *
+ * ★ 2026-09-25 新增：`distinguishes()` 那套是「**这些片段在不在**」，
+ * 而它能被一个**语义空转**的变体骗过 ——
+ *
+ *     if (e?.code === ABSENT) { /* 什么都不做 *\/ }
+ *     return undefined;         ← 读失败也降级了（= 事故本身）
+ *     throw e;                  ← 不可达
+ *
+ * 这个变体里 `code === ABSENT` 在、`throw e` 在、且 ABSENT 还排在 throw 前面
+ * ⇒ 旧判据**全绿**，而代码已经是"读失败静默变不存在"。这条洞是我自己在
+ * 对抗性变异里试出来的（不是被别人的例子提醒的），所以下面把判据从
+ * **"片段存在"** 收紧成 **"结构正确"**：守卫必须**真的**返回、"抛"必须**可达**。
+ */
+function catchInner(src) {
+  const body = codeOnly(blockAt(src, FN));
+  const ci = body.indexOf('catch');
+  if (ci < 0) return '';
+  const ob = body.indexOf('{', ci);
+  let depth = 0;
+  for (let i = ob; i < body.length; i++) {
+    if (body[i] === '{') depth++;
+    else if (body[i] === '}') { depth--; if (depth === 0) return body.slice(ob + 1, i); }
+  }
+  return '';
+}
+
+/**
+ * 「不存在」那一支必须**真的**返回 undefined。
+ *
+ * 允许 `if (c) return undefined;` 与 `if (c) { return undefined; }` 两种写法，
+ * 但**不接受**空转守卫（`{ }`）或不带 return 的守卫 —— 那正是上面那个骗过旧判据的变体。
+ */
+const absentGuard = () =>
+  new RegExp(`if\\s*\\(\\s*e\\?\\.code\\s*===\\s*['"\`]${ABSENT}['"\`]\\s*\\)\\s*(?:\\{\\s*)?return undefined\\s*;(?:\\s*\\})?`);
+
+const absentBranchReturnsUndefined = src => absentGuard().test(catchInner(src));
+
+/**
+ * 读失败必须**可达地**抛出：把「不存在」那一支摘掉之后，catch 里仍要有 `throw e`，
+ * 且它**前面不能有无条件的 `return undefined`**（那会让 throw 永不可达 ⇒ 又回到事故）。
+ */
+function unreachableThrowFree(src) {
+  const inner = catchInner(src);
+  const g = absentGuard().exec(inner);
+  if (!g) return false;
+  const before = inner.slice(0, g.index);
+  const after = inner.slice(g.index + g[0].length);
+  const th = after.indexOf('throw e');
+  if (th < 0) return false;
+  const between = after.slice(0, th);
+  return !/return\s+undefined/.test(before) && !/return\s+undefined/.test(between);
+}
+
+/** 判据整体：区分（片段）+ 顺序 + **结构**（守卫真的返回、抛真的可达） */
+const criterionPasses = src => distinguishes(src) && orderHolds(src)
+  && absentBranchReturnsUndefined(src) && unreachableThrowFree(src);
 
 test('★ persistedCwd 必须区分「不存在」与「读不出来」（只有前者能 create）', () => {
   assert.ok(SRC.indexOf(FN) >= 0, '找不到 persistedCwd —— 结构变了，判据要跟着改');
@@ -103,6 +159,16 @@ test('★ persistedCwd 必须区分「不存在」与「读不出来」（只有
   const catchBlock = body.slice(body.indexOf('catch'));
   assert.doesNotMatch(catchBlock, /catch\s*\([^)]*\)\s*\{\s*return undefined\s*;?\s*\}/,
     'catch 里不许无条件 `return undefined` —— 那等于把这次的修复又改回去了。');
+
+  // ⑤ ★ 结构判据（2026-09-25 补）：光有"片段"不够，守卫必须**真的**返回、抛必须**可达**。
+  //    否则 `if (c) { /* 空转 */ } return undefined; throw e;` 这种变体会全绿而过 ——
+  //    它语义上**就是事故本身**（读失败静默变"不存在"）。这条是我用对抗性变异自己试出来的。
+  assert.ok(absentBranchReturnsUndefined(SRC),
+    `「${ABSENT}」那一支必须**真的** ` + '`return undefined`（不能是空转守卫）——'
+    + '否则"不存在"不再返回 undefined，调用方永远走不到 create。');
+  assert.ok(unreachableThrowFree(SRC),
+    '`throw e` 必须**可达**：它前面（以及"不存在"那支之前）不许有无条件的 `return undefined`。'
+    + '一旦不可达，读失败就又静默降级成"不存在"了 —— 这正是事故的形状。');
 });
 
 /*
@@ -170,3 +236,37 @@ test('★ 变异③：throw 提到 code 判断之前（"不存在"也抛 ⇒ cre
   assert.equal(criterionPasses(mutated), false,
     '判据整体必须为假 —— 反过来的话，连"确实不存在"也会抛，create 永远不可达。');
 });
+
+test('★ 变异④（对抗性，我自己试出来的洞）：守卫**空转** + 无条件 return undefined + 不可达 throw ⇒ 必须红', () => {
+  // 2026-09-25：pi 复跑后我顺手拿"语义等价但形状不像"的变体做对抗测试，发现旧判据有洞：
+  //
+  //   } catch (e: any) {
+  //     if (e?.code === ABSENT) { /* 什么都不做 */ }   ← 片段"在"
+  //     return undefined;                              ← 读失败被降级（= 事故本身）
+  //     throw e;                                       ← 不可达
+  //   }
+  //
+  // 旧判据（distinguishes && orderHolds）对它**全绿**：code 比较在、throw e 在、
+  // ABSENT 还排在 throw 前面 —— 三条"片段存在"判据全过，而语义已经是事故。
+  // ⇒ "片段在不在"与"结构对不对"是两种性质，必须分开表达（与 orderHolds 同族的教训）。
+  let body = mutateInside(blockAt(SRC, FN),
+    /if \(e\?\.code === 'SESSION_QUERY_SESSION_NOT_FOUND'\) return undefined;/,
+    "if (e?.code === 'SESSION_QUERY_SESSION_NOT_FOUND') { /* 空转：什么都不做 */ }");
+  body = mutateInside(body, /^(\s*)throw e;$/m, '$1return undefined;\n$1throw e;');
+  const mutated = spliceBody(body);
+
+  // 前提：这个变体**确实**骗得过旧的两条判据（否则它没测到那个洞）
+  assert.equal(distinguishes(mutated), true,
+    '（前提）变异④ 保留了 code 比较与 `throw e` 片段 ⇒ `distinguishes()` 仍为真。');
+  assert.equal(orderHolds(mutated), true,
+    '（前提）ABSENT 仍排在 `throw e` 之前 ⇒ `orderHolds()` 也为真。'
+    + '正因如此，旧判据全绿 —— 这就是那个洞。');
+
+  // 新判据必须抓住它
+  assert.equal(absentBranchReturnsUndefined(mutated), false,
+    '守卫空转（`{ }` 而非 `return undefined`）时，结构判据必须为假。');
+  assert.equal(unreachableThrowFree(mutated), false,
+    '`throw e` 前出现无条件 `return undefined`（=> 不可达）时，结构判据必须为假。');
+  assert.equal(criterionPasses(mutated), false,
+    '判据整体必须为假 —— 否则"读失败静默变不存在"（事故本身）可以全绿通过。');
+});