dsh-rule-engine 0.6.0 → 0.6.2

package/lib/core/state.js

@@ -247,6 +247,7 @@ export function freshTurn() {
     realUserSeen: false, // v0.5.7：本回合是否有真实用户消息（注入轮不检测的依据）
     askSeen: false,
     askRejected: false, // 本回合 ask 已被拒（防连环 ask，弹窗消减）
+    askApproved: false, // 2026-09-06 M7 修复：本回合已获 ask 授权答复（M7 approval-gap 豁免信号）
     questionOnly: false,
     intents: null,
     intentState: "lexicon", // lexicon | llm-pending | llm-ready（LLM 意图兜底状态）

package/lib/core/text-detect.js

@@ -35,6 +35,15 @@ export const CRITICISM_WEAK_RE =
 
 export const DELIVERY_RE = /(?:已完成|全部(?:[^\s，。；！？]{0,12})完成|已[^\s，。；！？]{0,8}完成|修复完成|落盘完成|验证[^\s，。；！？]{0,6}(?:通过|成功)|全部通过|全部[^\s，。；！？]{0,10}通过|已通过|已修复|搞定)(?:\s*了|!|！|，[^。]*)?(?![^。]*(?:尚未|没有|未|没|还没|未完|待做|待完成))/;
 
+// 2026-09-06 0.6.x（tsk_527d222c 第一期）：路径缩写 B 级检测——回复含缩写路径（reports\ / ~/.dsh / %USERPROFILE%）
+// 且非完整盘符形态 → 提醒写完整绝对路径（规则 14⑤ 机器化第一层；WEAK 形态：留痕+注入，不拦截）
+const PATH_ABBREV_RE = /(?:^|[\s"'“”（(])(?:reports|~\/?\.dsh|%USERPROFILE%)[\\/]/i;
+const ABS_PATH_RE = /[A-Za-z]:[\\/][^\n]*/g;
+export function hasPathAbbrev(text) {
+  if (typeof text !== "string") return false;
+  return PATH_ABBREV_RE.test(String(text).replace(ABS_PATH_RE, ""));
+}
+
 /** 从 assistant message 内容中提取纯文本 */
 export function extractAssistantText(message) {
   if (!message) return "";
@@ -184,6 +193,16 @@ export function detectViolations({ configs, session, text, reasoningText = "", m
     });
   }
 
+  // 2026-09-06 0.6.x（tsk_527d222c 第一期）：路径缩写 B 级（规则 14⑤ 机器化——WEAK，留痕+注入不拦）
+  if (hasPathAbbrev(text)) {
+    hits.push({
+      ruleId: "14",
+      title: "汇报规范（完整文件位置路径）",
+      kind: "correct",
+      reason: "回复含缩写路径（reports\\ / ~/.dsh / %USERPROFILE% 等）——给用户应写完整盘符绝对路径（规则 14⑤）"
+    });
+  }
+
   const sourceCfg = byId.get("5");
   if (sourceCfg && !SOURCE_MARK.test(text)) {
     if (URL_RE.test(text)) {

package/lib/core/tool-catalog.js

@@ -26,6 +26,9 @@ const ANALYSIS_TOOLS = new Set([
   // 子代理交付工具（官方 dsh-tool-subagent-report，2026-08-24 实测发现）：仅子代理环境注册，
   // 参数仅 output 文本 → 直接交付父代理，无文件副作用 → analysis（避免子代理交付被 unknown deny 阻断）
   "report",
+  // 官方子代理模型发现（@deepseek-ai/dsh-tool-subagent，2026-09-06 工具目录漂移补录）：只读枚举
+  // 可用子代理模型（模型发现/所选路由校验），无持久副作用 → analysis
+  "list_subagent_models",
   // 官方 0.5.9 补全（tool-catalog 镜像 2026-08-27 交叉）
   "lsp",
   "session_event_read", "session_event_search", "session_event_trace", "session_search", "session_trace",

package/lib/index.js

@@ -563,7 +563,7 @@ export function handleSessionEvent(ctx, session, event) {
     if (!text) return;
     // 引擎自身注入的 [规则引擎] 提示不是用户消息，跳过——否则其中的“请直接执行”会被记录成授权（自我续授权漏洞）
     if (isEngineInjectedMessage(text)) return;
-    // 模板兜底（对 kind=user 同样生效，防"标 user 的注入"——super-injector createUserMessage 同类风险）：
+    // 模板兜底（对 kind=user 同样生效，防"标 user 的注入"——example-injector createUserMessage 同类风险）：
     // runtime context 快照 / 子代理完成通知 / vision-router 挂载提醒等已知注入模板 → 整体跳过
     if (isKnownSystemInjection(text)) {
       audit({
@@ -971,6 +971,7 @@ export function handleSessionEvent(ctx, session, event) {
       const result = d.result ?? d.value ?? d;
       if (askResultApproved(result)) {
         s.turn.realUserSeen = true; // v0.5.7：ask 弹窗答复也算"真实用户在场"
+        s.turn.askApproved = true; // 2026-09-06 M7 修复：ask 授权答复 = 本回合已授权（M7 approval-gap 豁免）
         const qText = askQuestionText(pending.questions);
         const selectedText = askResultSelectedText(result);
         // 授权范围只取“问题核心 + 用户实际选择”，不再把全部选项描述纳入；
@@ -1642,7 +1643,8 @@ export function apply(ctx) {
           // 边界裁决（v1.3 关键裁决 4）：正则保持无尾部 \b（保守匹配，xxx.mjs.bak 等变体同样命中）。
           if ((exec?.name === "pwsh" || exec?.name === "bash") && entryScript && new RegExp(`\\b${entryScript.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`).test(cmd)) {
             const s7 = getSessionState(state, sessionIdOfExec(exec));
-            if (needsApprovalReminder(s7.turn.userText || "")) {
+            // 2026-09-06 M7 修复：ask 授权答复（turn.askApproved）→ 豁免 approval-gap（12A 授权链已由 ask 建立）
+            if (needsApprovalReminder(s7.turn.userText || "", { askApproved: !!s7.turn.askApproved })) {
               audit({
                 kind: "approval-gap",
                 rule: "__approval-gap",

package/lib/service.js

@@ -64,9 +64,14 @@ class RuleEngineService extends TypertRemoteService {
 
   constructor(ctx) {
     super(ctx, "ruleEngine");
+    // 0.1.2 适配（2026-09-07，实markers 验证）：typert-protocol 0.1.2 Remote() 三分支——
+    // ① 一参字符串=exportName 工厂；② typeof 一参==='object'（含 null！）=流选项校验
+    //   （仅容 {mode:'stream'}，其余 TypeError——Remote(null,…) 在 0.1.2 因 typeof null===
+    //   'object' 落此分支崩溃，即本次升级事故 engine 侧根因；0.1.1 的 null 直落③分支）；
+    // ③ 一参 undefined + 二参 context=addMarkerInitializer(context,{kind:'direct'})。
+    // 手动标记形态=Remote(undefined, fakeContext)，context 含 {name,private,static,addInitializer}。
     for (const name of REMOTE_METHODS) {
-      Remote(null, {
-        kind: "method",
+      Remote(undefined, {
         name,
         private: false,
         static: false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-rule-engine",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "DSH 规则执行引擎 v3：容器解析 AGENTS.md + 理解器 + 匹配机 + 执行框架",
   "type": "module",
   "main": "lib/index.js",
@@ -49,8 +49,8 @@
     "check:meta": "node scripts/readme-version-check.mjs && node scripts/local-residue-scan.mjs"
   },
   "peerDependencies": {
-    "@deepseek-ai/dsh-home-paths": ">=0.1.0-rc.3 <0.2.0 || >=0.1.1-rc.0 <0.2.0",
-    "@deepseek-ai/dsh-typert-protocol": ">=0.1.0-rc.3 <0.2.0 || >=0.1.1-rc.0 <0.2.0"
+    "@deepseek-ai/dsh-home-paths": ">=0.1.0-rc.3 <0.2.0 || >=0.1.1-rc.0 <0.2.0 || >=0.1.2-rc.0 <0.2.0",
+    "@deepseek-ai/dsh-typert-protocol": ">=0.1.0-rc.3 <0.2.0 || >=0.1.1-rc.0 <0.2.0 || >=0.1.2-rc.0 <0.2.0"
   },
   "dsh": {
     "bundle": {

package/scripts/audit-mount-consistency.mjs

@@ -153,23 +153,23 @@ for (const [name, spec] of Object.entries(deps)) {
   }
 }
 
-// 3.5 runtime injection registry (super-injector) — also produces loader entries
+// 3.5 runtime injection registry (example-injector) — also produces loader entries
 console.log('\n=== 3.5 runtime injection registry ===')
-const superInjectorRegistry = join(DSH_HOME, 'super-injector', 'registry.json')
+const superInjectorRegistry = join(DSH_HOME, 'example-injector', 'registry.json')
 try {
   if (existsSync(superInjectorRegistry)) {
     const reg = JSON.parse(readFileSync(superInjectorRegistry, 'utf8'))
     if (!Array.isArray(reg)) throw new Error('registry.json is not an array')
     const names = reg.map((e) => e && e.name).filter(Boolean)
     for (const name of names) {
-      sources.push({ id: name, via: 'runtime injection (super-injector registry)', file: superInjectorRegistry })
+      sources.push({ id: name, via: 'runtime injection (example-injector registry)', file: superInjectorRegistry })
     }
     console.log('  runtime injected:', names.join(', ') || '(none)')
   } else {
-    console.log('  (no super-injector registry found; if dev_inject_plugin has been used, run dev_injected_list to confirm)')
+    console.log('  (no example-injector registry found; if dev_inject_plugin has been used, run dev_injected_list to confirm)')
   }
 } catch (e) {
-  console.log('  [WARN] failed to read super-injector registry:', e instanceof Error ? e.message : String(e))
+  console.log('  [WARN] failed to read example-injector registry:', e instanceof Error ? e.message : String(e))
 }
 
 // 4. duplicate detection across ALL sources

package/scripts/lib/pnpm-exempt.mjs

@@ -0,0 +1,56 @@
+// pnpm-exempt.mjs — pnpm-workspace minimumReleaseAgeExclude 豁免判定（verify-all ⑬ 与 release-plugin 预插共享单源）
+// 约定（exempt 语义）：行含包名（`pkg@`）且版本段任一匹配——yaml 支持 `- pkg@1.5.3 || 1.5.4` 形态（段可带/不带包名前缀）
+import { readFileSync, writeFileSync } from "node:fs";
+
+export function exemptPkg(wsYaml, pkg, ver) {
+  if (typeof wsYaml !== "string" || wsYaml.length === 0) return false;
+  return wsYaml.split(/\r?\n/).some((l) => l.includes(`${pkg}@`) && l.split(/\s*\|\|\s*/).some((tok) => {
+    const t = tok.trim().replace(/^-\s*/, "");
+    return t === ver || t === `${pkg}@${ver}`;
+  }));
+}
+
+/** 追加豁免行（已存在=幂等跳过；返回 {yaml, added}） */
+export function addExemptLine(wsYaml, pkg, ver) {
+  if (exemptPkg(wsYaml, pkg, ver)) return { yaml: wsYaml, added: false };
+  const sep = wsYaml.endsWith("\n") ? "" : "\n";
+  return { yaml: `${wsYaml}${sep}  - ${pkg}@${ver}\n`, added: true };
+}
+
+/** 读 yaml（fail-closed：读取失败抛错，调用方中止发布） */
+export function readYamlOrThrow(path) {
+  try {
+    const text = readFileSync(path, "utf8");
+    if (!text.includes("minimumReleaseAgeExclude")) throw new Error(`yaml 缺 minimumReleaseAgeExclude 块：${path}`);
+    return text;
+  } catch (e) {
+    if (e.code === "ENOENT") throw new Error(`yaml 不存在（fail-closed）：${path}`);
+    throw e;
+  }
+}
+
+/**
+ * 预插核心（release-plugin bump 后 publish 前调用；单测可注入 dryRun/write/log）：
+ * 已存在=幂等跳过；yaml 缺失/坏=抛错（fail-closed）；dryRun=只打印不写。
+ */
+export function ensureExempt(yamlPath, pkgName, ver, opts = {}) {
+  const { dryRun = false, write = (p, c) => writeFileSync(p, c, "utf8"), log = console.log } = opts;
+  let yaml;
+  try {
+    yaml = readYamlOrThrow(yamlPath);
+  } catch (e) {
+    throw new Error(`豁免预插失败（fail-closed 中止）：${e.message}`);
+  }
+  const { yaml: nextYaml, added } = addExemptLine(yaml, pkgName, ver);
+  if (dryRun) {
+    log(`[DRY-RUN] 豁免预插：${added ? `将追加 ${pkgName}@${ver}` : `已存在（幂等跳过）`}`);
+    return { added, dryRun: true };
+  }
+  if (added) {
+    write(yamlPath, nextYaml);
+    log(`豁免预插：+ ${pkgName}@${ver}`);
+  } else {
+    log(`豁免预插：${pkgName}@${ver} 已存在（幂等跳过）`);
+  }
+  return { added };
+}

package/scripts/release-plugin.mjs

@@ -12,9 +12,10 @@
 //       -> git commit+push -> gh release（带 tgz asset）
 // 安全：token 经环境变量注入，不在命令文本/日志中打印
 import { execSync } from "node:child_process";
-import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync, statSync, rmSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { ensureExempt } from "./lib/pnpm-exempt.mjs";
 
 const PROXY = process.env.DSH_RELEASE_PROXY || ""; // 默认直连；需要代理时显式设置
 /** 代理前缀（命令文本）：空 = 直连 */
@@ -216,6 +217,37 @@ console.log("\n=== 发布门禁 B1（README 版本四性）===");
 run(`cd /d "${dir}" && node scripts/readme-version-check.mjs`);
 console.log("\n=== 发布门禁 B2（lib/ 本机痕迹扫描）===");
 run(`cd /d "${dir}" && node scripts/local-residue-scan.mjs`);
+// ── 3.6 存在性扫描（泄露预防，2026-09-05）：本机增强门禁——REAL_PATHS_SCAN 指向存在性扫描器 →
+// 0 命中才继续；未设置=WARN（本机工具不进包，通用用户无此工具；发布流水线建议设置）──
+const scanReal = process.env.REAL_PATHS_SCAN;
+if (scanReal) {
+  console.log("\n=== 存在性扫描（真实路径判据，0 命中红线）===");
+  run(`node "${scanReal}" --root "${dir}"`);
+} else {
+  console.log("（未设置 REAL_PATHS_SCAN——存在性扫描跳过（本机增强门禁，建议发布前设置））");
+}
+console.log("（发布门禁 B1/B2/存在性 通过）");
+
+// ── 3.7 判据库回归（窗口 B 接入，2026-09-06）：净化判据（L1 敏感串全集全历史 0 非白名单 + L2 根段未覆盖 0）
+// 本机增强门禁——JUDGE_SCAN 指向本机判定门禁（stage1 判据库扫描器包装）；未设置=WARN ──
+const judgeScan = process.env.JUDGE_SCAN;
+if (judgeScan) {
+  console.log("\n=== 判据库回归（净化判据，0 非白名单 / 0 未覆盖 红线）===");
+  run(`node "${judgeScan}" --root "${dir}"`);
+} else {
+  console.log("（未设置 JUDGE_SCAN——判据库回归跳过（本机增强门禁，建议发布前设置））");
+}
+
+// ── 3.8 豁免预插（E7，2026-09-08 接线；单源 scripts/lib/pnpm-exempt.mjs）：bump 后 publish 前，
+// 把 nextVer 自动预插 profiles/web pnpm-workspace.yaml 的 minimumReleaseAgeExclude——⑬ 绝对口径
+// 要求"publish 后 latest ∈ 豁免名单"，预插保证该不变式由发布器维护（防手工遗忘 → 发布后 ⑬ 红）。
+// 幂等（已存在跳过）；DRY-RUN 只打印；yaml 读取失败抛错中止发布（fail-closed）。──
+{
+  const dshHome = process.env.DSH_HOME || join(process.env.USERPROFILE || "", ".dsh");
+  const yamlPath = join(dshHome, "profiles", "web", "pnpm-workspace.yaml");
+  console.log("\n=== 豁免预插（minimumReleaseAgeExclude ← nextVer）===");
+  ensureExempt(yamlPath, name, nextVer, { dryRun: !!process.env.DRY_RUN, log: console.log });
+}
 
 // ── 4. pack + publish ────────────────────────────────────────────
 console.log("\n=== npm pack ===");
@@ -223,6 +255,18 @@ run(`cd /d "${dir}" && npm pack --pack-destination .`);
 const tgz = `${name}-${nextVer}.tgz`;
 if (!existsSync(join(dir, tgz))) fail(`打包产物缺失：${tgz}`);
 
+// ── 4.5 发布物存在性扫描（泄露预防硬项，2026-09-05）：解包 tgz → 判据库直扫（0 命中才 publish）──
+const scanReal2 = process.env.REAL_PATHS_SCAN;
+if (scanReal2) {
+  const unpackDir = join(dir, ".pkg-check-" + nextVer);
+  if (existsSync(unpackDir)) rmSync(unpackDir, { recursive: true, force: true });
+  mkdirSync(unpackDir, { recursive: true });
+  run(`tar -xzf "${join(dir, tgz)}" -C "${unpackDir}"`);
+  console.log("\n=== 发布物存在性扫描（解包直扫，0 命中红线）===");
+  run(`node "${scanReal2}" --root "${join(unpackDir, "package")}"`);
+  console.log("（发布物存在性扫描通过）");
+}
+
 console.log("\n=== npm publish ===");
 run(`cd /d "${dir}" && ${proxyPrefix()}npm publish ${tgz}`);
 

package/scripts/verify-all.mjs

@@ -12,9 +12,10 @@
 // 任一 ❌ → exit 1；⚠️（WARN）不阻塞但必须明示。
 // 注意：子进程输出捕获需完整权限运行（受限模式 EPERM）。
 import { execFileSync } from "node:child_process";
-import { readdirSync, statSync, readFileSync } from "node:fs";
+import { readdirSync, statSync, readFileSync, existsSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { exemptPkg } from "./lib/pnpm-exempt.mjs";
 
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
 const lines = [];
@@ -130,6 +131,81 @@ step("发布门禁 B1（README 版本四性一致性：package.json/徽章/正
 // ── ⑩ 发布门禁 B2（阶段 B，2026-09-04：lib/ 本机痕迹扫描，词表唯一源）──
 step("发布门禁 B2（lib/ 本机痕迹扫描——词表唯一源，命中即红）", process.execPath, [join(root, "scripts", "local-residue-scan.mjs")]);
 
+// ── ⑪ 存在性扫描（泄露预防，2026-09-05：真实路径判据——REAL_PATHS_SCAN 指向扫描器，0 命中才算过；
+//    未设置=WARN（本机增强门禁，通用环境无此工具）──
+{
+  const scanReal = process.env.REAL_PATHS_SCAN;
+  if (scanReal) {
+    step("存在性扫描（真实路径判据，0 命中红线）", process.execPath, [scanReal, "--root", root]);
+  } else {
+    lines.push("⚠️ 存在性扫描：未设置 REAL_PATHS_SCAN（本机增强门禁；发布流水线建议设置）");
+  }
+}
+
+// ── ⑫ 判据库回归（窗口 B 接入，2026-09-06：净化判据 L1 敏感串全集全历史 0 非白名单 + L2 根段未覆盖 0
+//    红线——JUDGE_SCAN 指向本机判定门禁（stage1 判据库扫描器包装），未设置=WARN（本机增强门禁）──
+{
+  const judgeScan = process.env.JUDGE_SCAN;
+  if (judgeScan) {
+    step("判据库回归（净化判据全历史 0 非白名单 + L2 未覆盖 0 红线）", process.execPath, [judgeScan, "--root", root]);
+  } else {
+    lines.push("⚠️ 判据库回归：未设置 JUDGE_SCAN（本机增强门禁；发布流水线建议设置）");
+  }
+}
+
+// ── ⑬ pnpm 豁免校验（批次四 04 1.1 B1 口径；E-56 修活后为真跑校验：npm 已发布 latest 必须 ∈ minimumReleaseAgeExclude；
+//    绝对口径（12.4/13.2 裁定）：**link 装配不豁免**——四包 npm latest 必须 ∈ 豁免名单（防未来转非 link 装配踩坑 18）──
+{
+  try {
+    const dshHome = process.env.DSH_HOME || join(process.env.USERPROFILE || "", ".dsh");
+    const wsYaml = readFileSync(join(dshHome, "profiles", "web", "pnpm-workspace.yaml"), "utf8");
+    const profPkg = JSON.parse(readFileSync(join(dshHome, "profiles", "web", "package.json"), "utf8"));
+    const pkgVerLocal = (p) => { try { return JSON.parse(readFileSync(join(dshHome, "profiles", "web", "node_modules", p, "package.json"), "utf8")).version; } catch { return null; } };
+    const fourPkgs = ["dsh-rule-engine", "dsh-rules-manager", "dsh-rules-manager-client", "dsh-rule-engine-client"];
+    const misses = [];
+    const viewFails = [];
+    // 豁免判定（单源：scripts/lib/pnpm-exempt.mjs——与 release-plugin 预插共享；一致性测试锁）
+    const exempt = (p, v) => exemptPkg(wsYaml, p, v);
+    for (const p of fourPkgs) {
+      const spec = profPkg.dependencies?.[p];
+      if (!spec) continue;
+      const isLink = typeof spec === "string" && spec.startsWith("link:");
+      const esc = p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      // ⑬ 强校验（12.4 修法绝对口径）：npm 已发布 latest 必须 ∈ 豁免名单——**不因 link 装配豁免**
+      //（link 包其 npm 已发布版本仍须豁免——防未来转非 link 装配时踩坑 18）；本机版校验仅非 link 执行
+      let latest = null;
+      try {
+        const npmCli = join(dirname(process.execPath), "node_modules", "npm", "bin", "npm-cli.js");
+        latest = (process.platform === "win32" && existsSync(npmCli))
+          ? execFileSync(process.execPath, [npmCli, "view", p, "version"], { encoding: "utf8", stdio: "pipe" }).trim()
+          : execFileSync("npm", ["view", p, "version"], { encoding: "utf8", stdio: "pipe" }).trim();
+      } catch { latest = null; viewFails.push(p); }
+      if (latest && !exempt(p, latest)) {
+        misses.push(`${p}@${latest}（npm latest 未豁免）`);
+      }
+      if (!isLink) {
+        const ver = pkgVerLocal(p);
+        if (ver && !exempt(p, ver)) misses.push(`${p}@${ver}（本机版未豁免）`);
+      }
+    }
+    if (process.env.VERIFY_ALL_TESTMODE === "1") { misses.push("TESTMODE 合成 miss（门禁活性自证——必须转红）"); viewFails.push("TESTMODE-合成"); }
+    if (viewFails.length) {
+      // E2：发布语境（VERIFY_ALL_STRICT=1，release-plugin 3.7 设置）viewFails>0 计 ❌（fail-closed）；本地默认 ⚠️ 可见+抑制 ✅
+      const strictFail = process.env.VERIFY_ALL_STRICT === "1";
+      lines.push(strictFail
+        ? `❌ pnpm 豁免校验：npm view 执行失败 ${viewFails.length} 包（${viewFails.join("、")}）——发布语境 fail-closed（latest 未获取即阻断）`
+        : `⚠️ pnpm 豁免校验：npm view 执行失败 ${viewFails.length} 包（${viewFails.join("、")}）——latest 未获取（fail-closed：未完成≠通过）`);
+    }
+    if (misses.length) {
+      lines.push(`❌ pnpm 豁免校验：${misses.join("、")} 不在 minimumReleaseAgeExclude（发布后首装会被静默跳过——见踩坑 18）`);
+    } else if (!viewFails.length) {
+      lines.push("✅ pnpm 豁免校验（四包 npm latest 均已豁免）");
+    }
+  } catch (e) {
+    lines.push("⚠️ pnpm 豁免校验：读取失败（本机 profile 缺失时跳过）");
+  }
+}
+
 console.log(lines.join("\n"));
 const failed = lines.filter((l) => l.startsWith("❌"));
 if (failed.length) {