MailUI4Agents/client/electron/test/run-all.mjs

/**
 * 判据总入口 —— **全部跑完再算退出码**。
 *
 * 为什么不再用 `&&` 串起来：
 *
 * 原先 `npm test` 是 `a && b && c …`。这种行为有个不起眼但很贵的后果 ——
 * **前面红一条，后面全部不跑**。于是"只红了一条"看起来像"只有一个问题"，
 * 实际上后面那些判据连跑都没跑（这次就真发生了：`background` 红着，
 * `packaging` 从来没跑到过，而它正是能发现"界面改了没重打包"的那条）。
 * 换句话说：`&&` 链下的"全绿"是可信的，**"红"是不可信的**。
 *
 * 现在：每条判据都跑，红的收集起来，最后一起报、一起退出。
 *
 * 另外两条防"判据自己不会跑"的自检（与 process.exit 之后写判据是同一族问题）：
 *   1. 清单里的文件必须存在（名字写错 = 静默跳过一条判据）；
 *   2. `test/` 下的每个 `*.test.mjs` 都必须在清单里
 *      —— 这次 `cross-client-theme.test.mjs` 就是"写好了但没接进套件"，
 *      在它进套件之前一直是隐身状态。加了这条，**新增判据忘了接线会直接红**。
 *   3. 判据规范 `test/CRITERIA.md` 要在、且要点到那几条规则
 *      —— 写判据的规矩本身也会被"忘了带"（形状记在某个人的脑子里等于没有）。
 *
 * 写判据之前先读 `test/CRITERIA.md`（判结构与行为，不判字面与邻接）。
 */
import { prose } from './lib/read.mjs';
import { spawnSync } from 'node:child_process';
import { existsSync, readdirSync } from 'node:fs';
import { dirname, join } from 'node:path';
import { fileURLToPath } from 'node:url';

const HERE = dirname(fileURLToPath(import.meta.url));
const ROOT = join(HERE, '..');

/**
 * 判据清单：[文件, 额外 node 参数]。
 *
 * `--test` 给用 node:test 写的判据；鸿蒙那条要 `--experimental-strip-types`
 * 才能直接执行 `client/harmony/.../MailGrouping.ts`（判据跑的是客户端真正引用的那份逻辑）。
 */
/*
 * 自检 3：判据规范在不在、有没有写到那几条关键规则。
 *
 * 为什么把"文档"也判：`CRITERIA.md` 里的每条都是踩出来的（窗口式判据、邻接式判据、
 * 生成的清单被侵蚀、剥注释读不到理由……）。规则只在某个人的脑子里时，下一个人会重踩一遍；
 * 文件被删/被搬走却没人发现，等于规则也没了。这里只断"还在 + 关键条目还在"，
 * 不断它的措辞 —— 那是笔记，不是接口。
 */
const CRITERIA_DOC = join(HERE, 'CRITERIA.md');
if (!existsSync(CRITERIA_DOC)) {
  console.error('✗ 判据规范 test/CRITERIA.md 不见了（写判据的规矩不能只活在脑子里）');
  process.exit(1);
}
const criteriaDoc = prose(CRITERIA_DOC);
for (const must of ['配对/解析', 'allow-list', '变异验证', '剥掉注释', '按行', '自报条数', '只支撑你看到的那一层', '已经在某个提交里', '自带修法', '按 id 联接', '不要退化成对源码形状的匹配']) {
  if (!criteriaDoc.includes(must)) {
    console.error(`✗ 判据规范里少了「${must}」这条 —— 规则被删掉了还是搬走了？`);
    process.exit(1);
  }
}

const SUITE = [
  ['test/markdown-xss.test.mjs', [], 9],
  ['test/narrow-layout.test.mjs', [], 64],
  ['test/nav-merge.test.mjs', [], 8],
  ['test/theme.test.mjs', [], 30],
  ['test/background.test.mjs', [], 42],
  ['test/cross-client-theme.test.mjs', [], 15],
  ['test/harmony-logic.test.mjs', ['--experimental-strip-types', '--no-warnings'], 28],
  ['test/harmony-system-api.test.mjs', [], 5],
  // P4 外观同步：跑 model/Appearance.ts（纯逻辑），所以也要 strip-types
  ['test/harmony-appearance.test.mjs', ['--experimental-strip-types', '--no-warnings'], 24],
  // P5 悬浮玻璃导航：点击配对 / index 决定挂载 / 命中区 ≥44vp / 悬浮与让位
  ['test/harmony-nav.test.mjs', ['--experimental-strip-types', '--no-warnings'], 6],
  // 外观契约：默认值去 Go 源码里读（服务端 DefaultAppearance 是权威）+ 缓存键按账号
  ['test/appearance-defaults.test.mjs', [], 3],
  ['test/build-stamp.test.mjs', [], 7],
  ['test/packaging.test.mjs', [], 5],
  ['test/commit-hygiene.test.mjs', ['--experimental-strip-types', '--no-warnings'], 2],
  // 判据目录自身的卫生：读文本必须走 test/lib/read.mjs 的具名入口
  ['test/criteria-hygiene.test.mjs', [], 3]
];

// 自检 1：清单里的文件必须真的存在（写错名字 = 那条判据永远不跑）
const ghosts = SUITE.map(([f]) => f).filter((f) => !existsSync(join(ROOT, f)));
// 自检 2：test/ 下每个 *.test.mjs 都要在清单里（防"写好了没接线"）
const onDisk = readdirSync(join(ROOT, 'test'))
  .filter((f) => f.endsWith('.test.mjs'))
  .map((f) => `test/${f}`);
const unwired = onDisk.filter((f) => !SUITE.some(([s]) => s === f));

if (ghosts.length || unwired.length) {
  if (ghosts.length) console.error(`清单里的判据文件不存在：${ghosts.join('、')}`);
  if (unwired.length) {
    console.error(`这些判据文件没接进套件（写了却不会跑）：${unwired.join('、')}`);
  }
  process.exit(1);
}

/*
 * 自检 3：判据不得写在 `process.exit()` **之后**（pi 提议，2026-09-14）。
 *
 * 自检 1/2 管的是"文件没接线"，管不到"检查写在了退出之后" —— 而那正是实际发生过的
 * 第 4 例：4 条玻璃判据被并发写入落到了文件末尾、`process.exit()` 后面，
 * 于是**一条都不执行、也不计入通过/失败**，输出看起来完全正常。
 * 这种事的成因是结构性的（并发写入总是往文件末尾追加），所以它一定会再发生，
 * 而它下一次仍然不报错 —— 静态扫一遍最省事。
 */
const buried = [];
for (const [file, flags] of SUITE) {
  if (flags.includes('--test')) {
    continue; // node:test 那几条没有 process.exit，结构上不会踩这个
  }
  const src = prose(join(ROOT, file));
  const exitAt = src.lastIndexOf('process.exit(');
  if (exitAt >= 0 && /(^|\n)\s*check\(/.test(src.slice(exitAt))) {
    buried.push(file);
  }
}
if (buried.length) {
  console.error(`判据写在 process.exit() 之后，永远不会跑（挪到汇总之前）：${buried.join('、')}`);
  process.exit(1);
}

/*
 * 自检 4（pi 2026-09-14 提的家族，第 6 例）：**"判据自己不会跑"**。
 * 第 6 例的宿主是 runner 自己：清单里的 flag 与判据写法如果配错，症状是"看起来全绿"。
 *
 * ⚠️ 落地前先实测了两条真实样本，结论与 pi 的猜测**不同**，记在这里免得后人重猜：
 *   - `node --test <自定义 check() 的判据>`：**退出码照样传出来**（文件 exit 1 → 命令行 exit 1），
 *     并没有被 runner 吞掉；
 *   - 但 `node --test <什么都不做的文件>` 会报 `# tests 1 / # pass 1` ——
 *     **计数不是"检查跑过"的证据**。所以"解析 pass 计数、0 就判红"这条路既
 *     抓不到空判据（它报 1），又会在 `narrow-layout`（汇总行"全部通过"里没有数字）上误报。
 *
 * 换成**结构证据**：每条判据文件里必须存在"能红"的路径 ——
 * node:test 的 `test(`、自定义 `check(`、或显式 `process.exit(1)`。
 * 一个都没有 = 它永远不会红，与"全通过"长得一模一样。
 * 再加一条"跑完必须有输出"（12 条判据现在都有输出），静默成功同样可疑。
 */
function shapeOf(file) {
  const src = prose(join(ROOT, file));
  const usesNodeTest = /from 'node:test'/.test(src);
  const canFail = usesNodeTest
    || /(^|[^.\w])check\(/.test(src)
    || /process\.exit\(\s*1\s*\)/.test(src);
  return { usesNodeTest, canFail };
}

const shapeless = [];
for (const [file, flags] of SUITE) {
  if (flags.includes('--test')) {
    console.error(`清单里不要手写 --test（它由文件内容推导）：${file}`);
    process.exit(1);
  }
  if (!existsSync(join(ROOT, file))) continue; // 自检 1 已经报过了
  if (!shapeOf(file).canFail) shapeless.push(file);
}
if (shapeless.length) {
  console.error('这些判据文件里找不到任何"能红"的路径（test( / check( / process.exit(1)）：'
    + `${shapeless.join('、')} —— 它们永远不会红，与"全通过"看起来一样`);
  process.exit(1);
}

const reds = [];
const brokens = [];
for (const [file, flags, expected] of SUITE) {
  console.log(`\n========== ${file} ==========`);
  const shape = shapeOf(file);
  const all = shape.usesNodeTest ? [...flags, '--test'] : flags;
  // 收集输出再自己打回去：观感不变（stdio:'inherit' 的等价物），但能顺手做"跑了吗"的检查
  const r = spawnSync(process.execPath, [...all, join(ROOT, file)], { encoding: 'utf8' });
  const out = (r.stdout || '') + (r.stderr || '');
  process.stdout.write(r.stdout || '');
  process.stderr.write(r.stderr || '');
  /*
   * `broken` 与 `red` 必须分开（pi 2026-09-14 §3）。
   *
   * 我这轮两次把"跑不起来"当成"判据红了"：一次变异注入少了 import（报 build failed）、
   * 一次判据里写了没绑定的标识符（ReferenceError 抛在判据自己身上）。
   * 两者的后果都是同一种骗人方式：**看起来像判据失败，其实是判据没跑**。
   * 所以判据是：退出码非零 **且输出里没有一句"断言失败"** → 那是 broken（崩了），不是 red。
   * 变体验证里出现 broken = **这次变异无效，重做**，不许记成"红过了"。
   */
  /*
   * 判据是"输出里有**语言级崩**的痕迹"，不是"有没有 `not ok`"。
   * 第一版我用后者，当场误判：node:test 会把**导入期**的 ReferenceError 也报成
   * `not ok 1 - …`，于是"崩了"看起来和"断言失败"一模一样 —— 正是这条判据要治的病。
   */
  const CRASH_SIGNS = /(SyntaxError|ReferenceError|TypeError|Cannot find module|ERR_MODULE_NOT_FOUND|is not defined|is not a function|CompileError|build failed|Unexpected identifier|missing ',' in argument list)/;
  const crashed = r.status !== 0 && CRASH_SIGNS.test(out);
  const empty = out.trim().length === 0;
  // 不 break：后面每条都要跑出来，否则"红了几条"这个信息本身是假的
  if (crashed || empty) {
    const firstErr = (out.match(/^.*(Error|error:).*$/m) || [''])[0].trim().slice(0, 160);
    brokens.push(`${file}（${empty ? '跑完没有任何输出' : `退出码 ${r.status}，但没有一句断言失败`}）` +
      (firstErr ? `\n      ↳ ${firstErr}` : '') +
      '\n      ↳ 这是 **broken（跑不起来）**，不是 red：它证明不了任何判据成立或不成立。' +
      '\n        常见成因：语法/标识符错（`X is not defined`）、import 写错、编译不过。' +
      '\n        用于变体验证时：broken **不算这次变异有效**，要重做。');
  } else if (r.status !== 0) reds.push(`${file}（退出码 ${r.status}）`);
  else {
    /*
     * 自报条数（闭环）：自定义 check() 打 `RESULT pass=N fail=M`，node:test 打 `# pass N`。
     * 只解析**固定 marker**，不去猜口语汇总（「窄屏布局：全部通过」里没有数字，
     * 靠猜数字的写法会误报 —— pi 提过，我也先贴过真实样本）。
     */
    const marker = /RESULT pass=(\d+) fail=(\d+)/.exec(out);
    const nodeTest = /^# pass (\d+)/m.exec(out);
    const ran = marker ? Number(marker[1]) : (nodeTest ? Number(nodeTest[1]) : null);
    if (ran === null) {
      /*
       * 报错**自带修法**（pi 2026-09-14）：这条契约的受众不只是读过规范的人 ——
       * 并发写 WebUI 的 agent 新加判据时不会打开 CRITERIA.md，看到红的第一反应
       * 很可能是"套件坏了"（删自检、往清单里塞豁免）。**red 是 ta 一定会看到的东西，
       * 文档不一定会被打开** —— 所以把修法直接写进这条错误里，并给出可抄的样板。
       */
      reds.push(`${file}
      ↳ 没找到自报条数。修法（二选一）：
        1) 用共享 helper（新判据推荐）：
             import { check, finish } from './lib/checks.mjs';
             check('判据名', 条件, '失败时给人看的细节');
             finish('标签');            // 它负责打 RESULT pass=N fail=M
           样板：test/markdown-xss.test.mjs、test/narrow-layout.test.mjs
        2) 自己打一行（老写法，计数必须写在 check() 内部，否则"实现被换空"看不见）：
             console.log(\`RESULT pass=\${pass} fail=\${fail}\`);
           样板：test/theme.test.mjs、test/background.test.mjs
       （用 node:test 写的判据不用管：runner 认 \`# pass N\`。）`);
    } else if (expected > 0 && ran < expected) {
      reds.push(`${file}
      ↳ 自报 ${ran} 条 < 清单里登记的 ${expected} 条。常见成因：判据被删/被跳过（写在 process.exit() 之后、
        条件里提前 return）、check() 的实现被改坏（合并冲突）、marker 打在了汇总之前但计数没接上。
        确认确实该减少条数时，把清单里那个数字一起改掉（那是一次显式、可复核的编辑）。`);
    }
  }
}

/*
 * ─── 静态判据的**欠账**与到期机制（pi 2026-09-14 提议） ───
 *
 * 有些判据只能验**形态**（读 `.ets` 源码），因为它们要验的东西在本机跑不起来：
 * 鸿蒙侧编译要 hvigorw、运行要设备/模拟器。这类判据登记在下面，并各自写清
 * **什么前提一旦成立它就过期**。
 *
 * 为什么不能只写一句"暂时"：**"暂时"不是一种状态，是一个待办** —— 规范里写下的
 * "暂时"没有任何机制会回来读它，于是永远留在原地。这里把它变成可机检的形状：
 *   1. `UNBLOCK` 必须是**可检测的前提**（这里就是"有没有可用设备"），不是陈述；
 *   2. 汇总里打 `RESULT static=N` —— 这是**欠账余额**，涨了要看得见；
 *   3. **前提一旦为真，欠账当场变红**：不等人想起来，设备可用的那天这些判据必须
 *      改成行为判据（或明确降级并写理由）。
 *
 * 这条是"自报 0 条 < 登记条数"的**时间版本**：那条管"判据还在不在"，这条管
 * "它该升级了没有"。
 */
/**
 * 探针：判定静态判据的"到期前提"是否成立。
 *
 * # 三值，不是两值（pi 2026-09-14 §2）
 *
 * 原先只有"成立/不成立"两种结果，于是**"探针跑不了"和"设备不可用"被归成同一格**：
 * 设备那天真可用了，闸门也永远不会开 —— 机制在，闸门锈死，而且看起来完全健康
 * （这是"自报 0 条 < 登记 30 条"的第三种形状：探针自己坏了，没人知道）。
 *
 * 所以：
 *   - `true`    可用（前提成立 → 依赖它的静态判据**到期**，必须处理）；
 *   - `false`   不可用（探针**确实跑成了**，结论是没有目标）；
 *   - `'unknown'` 拿不准（**命令在但跑不成**：超时、非零退出、抛异常）→ **按到期处理**。
 *
 * # 这条设计当场抓到了什么（写下来，因为它是"闸门锈死"的实证）
 *
 * 换三值之后第一次运行就报了 `probe=unknown` —— 一查：探针里调的是 `execFileSync`，
 * 而这个文件 import 的是 `spawnSync`（**名字根本没定义**）。也就是说
 * **探针从写下的那天起一次都没跑成过**，而旧的二值设计把 `ReferenceError`
 * 连同"没有设备"一起吞掉、统一报成"设备不可用"——**机制在、闸门从来没开过，
 * 而它看起来完全健康**。三值把它变成了一声明确的红：探针自己坏了，必须有人看一眼。
 *
 * 另外，`'unknown'` 只留给"命令在、但跑不成"；**所有候选都不存在**（本机没装 hdc）
 * 是可判的事实（没有工具就不可能有设备），报 `false`，否则没装 SDK 的机器会天天假红。
 *     拿不准就红，让人看一眼 —— 这条判断比"猜一个"便宜得多。
 *
 * 测试用 `AGENTMAIL_PROBE_DEVICE=ok|none|unknown` 覆盖（判据自检要用：
 * 没有这个开关就没法验证"unknown 会不会红"）。
 */
const PROBES = {
  device: {
    // 前提写成"**本工作区**能装能点设备"，不是"机器上有设备"（pi 2026-09-14）：
    // 同一台机器上设备对 gui-lab 那条通道可用、对我这条不可用 —— 写"机器上有设备"的话，
    // 探针变真会让 5 条判据同时红，而**我修不了**（要写 /run、/var/log，在工作区外）。
    // 写成"本工作区能装能点"，红就只在我能动手时出现。
    desc: '本工作区能装、能点设备（hdc 服务健康 + 看得到目标）',
    need: [
      '设备/模拟器要在本工作区里起得来：模拟器启动要写 /run/harmony-emulator.pid 与 /var/log/harmony-emulator.log',
      'hdc 的**服务端**要健康（`hdc -m` 在跑）；服务端起不来时 `list targets` 也会打印 [Empty]，那是"拿不准"不是"没设备"',
      '要有 hdc 目标；能装上 hap 并能点（hvigorw assembleHap + hdc install）'
    ],
    run() {
      const override = process.env.AGENTMAIL_PROBE_DEVICE;
      if (override === 'ok') return true;
      if (override === 'none') return false;
      if (override === 'unknown') return 'unknown';

      /*
       * # 候选清单的权威性（pi 2026-09-14 §2：硬编码清单今天咬了两次）
       *
       * 上一版在**固定两条路径**里找 hdc，全不在就判"本机没装 → 没有设备"（false）。
       * 这与 build.sh 在固定几个根里找 SDK 源码、第一个命中就用，是**同一个形状**：
       * 硬编码清单 + "命中/未命中"当真值。那次命中了 /root/ha-test 的老 checkout，
       * 于是把错误结论当成了事实。所以这里：
       *   ① 候选来源写清楚（下面 TOOLCHAIN_ROOT 是华为命令行工具的**文档安装根**）；
       *   ② **工具链根在、里面却没有 hdc** → `unknown`（不是"没装"，是"装了但长得不一样"）；
       *   ③ `hdc` 也走 PATH（spawnSync 自己会查 PATH），不再只认那一条写死的路径。
       */
      const TOOLCHAIN_ROOT = '/opt/huawei/command-line-tools';
      const sdkHdc = `${TOOLCHAIN_ROOT}/sdk/default/openharmony/toolchains/hdc`;
      const candidates = [sdkHdc, 'hdc'];

      let ranOnce = false;      // 至少有一条命令**跑成过**（哪怕是"没有目标"）
      let sawEmpty = false;
      let anomaly = '';         // 命令在，但跑不成（超时/非零退出/…）—— "拿不准"
      let allMissing = true;    // 所有候选都不存在
      for (const bin of candidates) {
        const r = spawnSync(bin, ['list', 'targets'], { encoding: 'utf8', timeout: 15000 });
        if (r.error && r.error.code === 'ENOENT') continue;
        allMissing = false;
        if (r.error) { anomaly = r.error.code || String(r.error.message || r.error); continue; }
        if (r.status !== 0) { anomaly = `exit ${r.status}`; continue; }
        ranOnce = true;
        const t = (r.stdout || '').trim();
        if (t && !/\[Empty\]/.test(t)) return true;          // 明确可用
        sawEmpty = true;                                       // "没有目标"（下面还要问服务端健不健康）
      }

      /*
       * `[Empty]` **不等于**"没有设备"（pi 2026-09-14 §1）。
       *
       * 它至少混三种原因：① 真没有设备；② **hdc 自己的服务端起不来**
       * （socket/权限 —— 而"要写工作区外的目录"正是我这轮撞上的限制）；
       * ③ 被打印成空集的权限拒。所以先证服务端健康，才敢把空集当成"可判的没有"：
       * 服务端进程在（`hdc -m`，含它在别的路径下）→ 空集是可判事实 → false；
       * 服务端找不到 → 空集可能正是"探针自己被环境弄坏了" → unknown（红）。
       */
      if (ranOnce && sawEmpty) {
        return hdcServerLooksHealthy() ? false : 'unknown';
      }
      if (anomaly) return 'unknown';                           // 命令在、跑不成 → 拿不准
      if (allMissing) {
        // 工具链根在、里面却没有 hdc → "装了但长得不一样"，不是"没装"
        return existsSync(TOOLCHAIN_ROOT) ? 'unknown' : false;
      }
      return 'unknown';
    }
  }
};

/**
 * hdc 的服务端是不是在跑。只读 /proc/<pid>/cmdline（不依赖 `ps` 也不起子进程
 * —— 探针自己不该再引入"命令跑不起来"这种不确定性。
 * 判据：命令行里第二个参数是 `-m`（hdc 的 server 模式）。
 */
function hdcServerLooksHealthy() {
  let pids = [];
  try { pids = readdirSync('/proc').filter(d => /^\d+$/.test(d)); } catch { return false; }
  for (const pid of pids) {
    try {
      // 走 lib/read.mjs 的 prose（判据目录不许裸 readFileSync —— 那条判据也管这里）
      const cmd = prose(`/proc/${pid}/cmdline`).split('\0').filter(Boolean);
      if (cmd.length && /(^|\/)hdc$/.test(cmd[0]) && cmd.includes('-m')) return true;
    } catch { /* 进程刚退出 / 没权限读 —— 换下一个 */ }
  }
  return false;
}


/** 探针结论 → 是否等于"前提成立（到期）" */
const probeIsDue = v => v === true || v === 'unknown';

/** 只能验形态的判据：文件 + 为什么只能静态 + 到期前提 */
/*
 * 探针自检（`--probe-selftest`）：它判的是**判据自己的分辨力** ——
 * "unknown 到底会不会红"。没有这条，`probeIsDue` 哪天被改成 `v === true`
 * 也没人会发现，而那正是"闸门锈死"的写法。
 */
if (process.argv.includes('--probe-selftest')) {
  const cases = [
    ['ok 可用 → 到期', true, true],
    ['none 不可用 → 不到期', false, false],
    ['unknown 拿不准 → 到期（必须红）', 'unknown', true],
  ];
  let bad = 0;
  for (const [what, value, want] of cases) {
    const got = probeIsDue(value);
    console.log(`${got === want ? 'ok  ' : 'RED '} ${what}（probeIsDue(${JSON.stringify(value)}) = ${got}）`);
    if (got !== want) bad++;
  }
  process.exit(bad ? 1 : 0);
}
const STATIC_ONLY = [
  ['test/harmony-nav.test.mjs', '底栏结构/命中区常量/挂载关系：`.ets` 要 hvigorw 才能编译、要设备才能点', 'device'],
  ['test/harmony-appearance.test.mjs', '壁纸/令牌/遮罩渲染：观感与运行期换肤要设备', 'device'],
  ['test/harmony-logic.test.mjs', '页面状态机与文案：`.ets` 状态要跑起来才算数', 'device'],
  ['test/cross-client-theme.test.mjs', '跨端令牌与玻璃分工：一端是 `.ets`，只能静态对齐', 'device'],
  ['test/appearance-defaults.test.mjs', '默认值契约里 `.ets` 那半：运行时行为要设备', 'device']
];

for (const [file, , probe] of STATIC_ONLY) {
  if (!SUITE.some(([f]) => f === file)) {
    console.error(`✗ 静态判据登记里的 ${file} 不在套件清单里（登记要跟着套件走）`);
    process.exit(1);
  }
  if (!PROBES[probe]) {
    console.error(`✗ ${file} 的到期前提 \`${probe}\` 不是已知探针（UNBLOCK 必须是可机检的前提，不是一句陈述）`);
    process.exit(1);
  }
}
const probeResults = {};
for (const [, , probe] of STATIC_ONLY) {
  if (probeResults[probe] === undefined) probeResults[probe] = PROBES[probe].run();
}

const dueStatic = STATIC_ONLY.filter(([, , probe]) => probeIsDue(probeResults[probe]));
const unknownProbes = Object.entries(probeResults).filter(([, v]) => v === 'unknown').map(([k]) => k);
if (dueStatic.length > 0) {
  const firstUnknown = unknownProbes.includes(dueStatic[0][2]);
  console.error(firstUnknown
    ? `\n✗ 探针**跑不了**（${PROBES[dueStatic[0][2]].desc}）—— 拿不准就按到期处理，别让闸门锈死：`
    : `\n✗ 静态判据**到期**了：${PROBES[dueStatic[0][2]].desc} 现在是成立的 ——`);
  for (const [file, why, probe] of dueStatic) {
    console.error(`  - ${file}（到期前提：${PROBES[probe].desc}；当初只能静态的原因：${why}）`);
  }
  console.error(
    '  这些判据当时只能验形态。前提成立后必须做其中一件（别默默留着）：\n' +
    '    a) 改成**行为判据**（真跑一遍/真点一次），静态那条降级或删掉；\n' +
    '    b) 明确写"为什么仍然只能静态"（如设备能编译但点不了），并改换一个更准的到期前提。\n' +
    '  这是"暂时"的到期机制：它的作用就是不等谁想起来。'
  );
  /*
   * 到期报文自带**要人做什么**（pi 2026-09-14 §2）：
   * 这条红第一次出现时，最可能的结局是"被当成噪音消掉"——因为看的人不知道要放行什么。
   * 前提写的是"**本工作区**能装能点"，所以这里把工作区外的门槛逐条列出来。
   */
  const need = PROBES[dueStatic[0][2]].need || [];
  if (need.length) {
    console.error('  要让它变成行为判据，需要先在本工作区打通：');
    for (const n of need) console.error(`    · ${n}`);
    console.error('  这些都在工作区外（需要人放行或提权）—— 所以这条红**不要求你现在修**，' +
      '要求的是：别把它当噪音，并在打通后回来把静态那条升级掉。');
  }
  process.exit(1);
}
/*
 * 汇总里"欠账余额"和"探针是否健康"是两个不同的数字（pi §2）：
 *   static=5   —— 还欠着 5 条只能验形态的判据；
 *   probe=ok   —— 探针自己是好的（unknown 说明闸门可能锈死了，得人看一眼）。
 */
const probeSummary = unknownProbes.length ? 'unknown' : 'ok';
console.log(`RESULT static=${STATIC_ONLY.length} probe=${probeSummary}` +
  (unknownProbes.length ? `（探针跑不了：${unknownProbes.join('、')} —— 已按到期处理）`
                        : '（只能验形态的判据：到期前提成立就自动变红）'));

console.log(`\n========== 判据汇总 ==========`);
if (reds.length === 0 && brokens.length === 0) {
  console.log(`全部通过（${SUITE.length} 个判据文件：${SUITE.map(([f]) => f.replace('test/', '').replace('.test.mjs', '')).join('、')}）`);
  process.exit(0);
}
// broken 先报：它比红更严重（红是"判据说不成立"，broken 是"判据没说话"）
if (brokens.length) {
  console.error(`跑不起来的判据（${brokens.length}/${SUITE.length}）—— 不是红，也不算过：`);
  for (const b of brokens) console.error(`  - ${b}`);
}
if (reds.length) {
  console.error(`红的判据（${reds.length}/${SUITE.length}）：`);
  for (const r of reds) console.error(`  - ${r}`);
}
process.exit(1);