@whyshu/argent-engine 0.0.0-stage → 0.6.0

package/engine/scripts/check-production-home.mjs

@@ -0,0 +1,602 @@
+#!/usr/bin/env node
+/**
+ * check-production-home —— 「**生产归属**」只读门禁（P0 0.7，2026-10-03）
+ *
+ * ## 为什么有它
+ * 「本机（chester Mac）= 开发机，**不跑生产**；生产在客户机 Huangwei」这条纪律此前**只有文档约束**
+ * （`~/.dsh/AGENTS.md`「机器角色」）。而 2026-10-02 真出过事故：误信"本机代客户机跑生产"，
+ * 把本机的 4 个 `com.whyshu.flow-trigger-*` 重新 bootstrap，结果**与客户机同抢同一批生产行**
+ * （实测同 3 张日报票两机各自 `planned`）。根因是结构性的、不会自己消失：
+ *   · 台账是**每机独立文件**、lease **没有跨机互斥** ⇒ 两端同跑**必然**抢行；
+ *   · 判据（"本机 flow-trigger 必须为 0"）是**可机器判定**的，却没人每次开窗前跑一遍。
+ * 所以把它固化成一条**只报告**的检查：只读 `launchctl list`，**绝不** bootout/bootstrap/kickstart。
+ *
+ * ## 判据（唯一口径，改判据只改 `CRITERION`；**分角色档**）
+ *
+ * ### 档位 `dev`（缺省；**语义与退出码与 2026-10-03 版完全一致**，向后兼容）
+ * 1. **fail**：`launchctl list` 里 label 命中 `flow-trigger` ⇒ 本机加载了生产触发器（**硬判据 = 0**）。
+ * 2. **warn**：名字像**生产型调度器**（`*poll*` / `*invoice*` / `*fulfillment*` / `*flow-timers*` /
+ *    `argent-bridge`）的非 flow-trigger label —— 同一类"双跑"风险（本机跑 ⇒ 与客户机抢行）。
+ * 3. **info**：本机磁盘上**存在** flow-trigger 的 plist 但**没加载** —— 这是"现成弹药"，
+ *    提示"别 bootstrap"；不判红（未加载就是正确姿态）。
+ *    ⚠️ **磁盘存在 ≠ 未加载**（2026-10-04 修正）：已加载的 plist **不会**出现在这条 info 里
+ *    （它已经被第 1 条按 `launchctl list` 实际状态judged了）—— 旧版对已加载的也印"未加载"，是误报。
+ * 4. **warn（证据不足）**：`launchctl` 跑不起来 / 输出解析不出任何行 ⇒ **不能证明**姿态正确。
+ *
+ * ### 档位 `production`（客户机 Huangwei；`--role production` 或 `--expect-flow-triggers <N>`）
+ * 生产机与开发机是**相反**的期望：开发机要求 **0 条**，生产机要求**恰好 N 条且全活**。
+ * 把开发机的判据套到生产机上 ⇒ **必然判红**（客户机实测 4 条 fail，而那 4 条 label 正是期望值）。
+ * | # | 判据 | 级别 |
+ * |---|---|---|
+ * | P1 | flow-trigger 计数**恰等于**期望值（缺省 **4** = 客户机在册的生产流程条数；`--expect-flow-triggers N` 覆盖） | **fail** |
+ * | P2 | 每个已加载 flow-trigger 的 `last exit code` **全 0**（非 0 ⇒ 该触发器在失败循环里） | **fail** |
+ * | P3 | 磁盘在册（`~/Library/LaunchAgents` 有同名 plist）但**未加载**的 flow-trigger：生产机应全活 | **warn** |
+ * | P4 | 加载了**不在册**的 flow-trigger（磁盘上找不到同名 plist ⇒ 来源不明） | **warn** |
+ * | P5 | 数据目录里有 `PAUSE_*` 开关：客户机应保持**全活**（有开关 = 生产被挡住）；含义见输出 | **warn** |
+ * 生产档下 P1/P2 之外的"生产型调度器"告警与开发档一致（同一类双跑风险）。
+ * ⚠️ 判据**不写死业务 label 名**：期望条数是数字（`--expect-flow-triggers`），"在册"由机器侧
+ * `~/Library/LaunchAgents` 的 plist 对齐 —— 引擎只认功能，不把厂商/业务名抄进判据。
+ *
+ * ## 输出与退出码（对齐 `scripts/check-docs-drift.mjs` 的"只报告"口径）
+ *   node scripts/check-production-home.mjs                      # 只报告，**恒 exit 0**（除非用法错误）
+ *   node scripts/check-production-home.mjs --role production     # **客户机（生产机）**档：恰好 4 条且全活
+ *   node scripts/check-production-home.mjs --expect-flow-triggers 4   # 同上（显式期望条数）
+ *   node scripts/check-production-home.mjs --strict             # 有 fail/warn ⇒ exit 1
+ *   node scripts/check-production-home.mjs --json               # 机器可读（stdout 只有一份 JSON）
+ *   node scripts/check-production-home.mjs --launchctl-output <file>   # 用文件当 launchctl 输出（纯夹具测试用）
+ *   node scripts/check-production-home.mjs --data-dir <dir>     # 覆盖数据目录（查遗留 PAUSE_* 开关；夹具用）
+ *   node scripts/check-production-home.mjs --launchagents-dir <dir>    # 覆盖 LaunchAgents 目录（夹具用）
+ *   退出码：`0` 检查完成（默认模式**恒 0**）｜`1` `--strict` 且有 fail/warn｜`2` 用法错误
+ *   （⛔ 不用 `3`：按 D4 裁定，`3` **只**表示"许可宽限放行"。）
+ *
+ * ## 排程面体检（P1-A，2026-10-12；**只读，且永不计入 fail**）
+ * 把定时从 `flow-trigger*` 换成**宿主原生排程**之后，观测面会整体搬家（投递失败只写宿主日志、不重试；
+ * 回执只证"进收件箱"不证"模型跑了"）⇒ 这个门禁顺带看一眼排程面（判据 = `scripts/lib/schedule-probe.mjs`
+ * 的四道闸，⚠️ **同一份实现**，⛔ 不在这里另写一套）：
+ *   · **默认（离线）**：排程域文件（`<DSH_HOME>/storages/schedule*`）可解析性 + 注册表里的
+ *     `trigger.schedule` 声明面。**只读文件**，另外会 spawn **一次** `python3 flow_registry.py --json`
+ *     （Node 侧注册表唯一加载器 `scripts/lib/registry.mjs`）——这是本开关带来的唯一新子进程。
+ *   · `--schedule-online`：额外跑 ①②③ 三闸（`POST <base>/api/schedule/catalog` + 读**唤醒凭据**签 cookie，
+ *     与 `scripts/flow-trigger-wake.mjs` 同一条链、**只读**）—— 此时它**会**读凭据文件并访问 `127.0.0.1`。
+ *   · `--no-schedule`：整段关掉（行为与 2026-10-04 版逐字一致）。
+ *   · 严重度上限 = **warn**（从不 fail）：红线判据在 `node scripts/argent-schedule.mjs check`（exit 0/1/2）；
+ *     本门禁只保证"姿态里能看见排程面"。⇒ **开发机默认档不会因为它变红**（无 warn、exit 0）。
+ *   · 过渡态（本批的已知状态）：声明已就位但宿主**没挂载**或**没建任务** ⇒ 只报 **info**（不是故障）。
+ *
+ * ## ⚠️ 在客户机上怎么跑（2026-10-04）
+ * ```bash
+ * node scripts/check-production-home.mjs --role production     # ✅ 客户机（生产机）用这个
+ * node scripts/check-production-home.mjs                       # 开发机（本机）用默认档，仍要求 0 条
+ * ```
+ * ⛔ **它是 Node 脚本，不是 bash**：`bash scripts/check-production-home.mjs --role production` 跑不起来
+ * （bash 会把它当 shell 语法解析）。
+ *
+ * ## 纪律
+ *   · **只读**：不写任何文件、不改 launchd、不读凭据（除非显式 `--schedule-online`）、不联网
+ *     （`--schedule-online` 只访问 `127.0.0.1` 的宿主）。默认唯一子进程是 `launchctl list`
+ *     （`--no-schedule` 也不会去掉它；`--schedule-online` 另加"注册表加载器 + 一次本地 POST"）。
+ *   · **不代劳**：发现 flow-trigger 只打印"后果 + 正确做法"，**绝不**自动 bootout（那正是事故的动作）。
+ *   · 本脚本**不接** `run-tests.sh` 的失败判据（本机姿态常年可能有人为偏差，接进去就是恒红陷阱）；
+ *     回归只覆盖 `scripts/tests/production-home.test.mjs` 的**纯夹具**（注入 launchctl 输出）。
+ */
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { spawnSync } from 'node:child_process'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { resolveDataDir } from '../core/lib/argent-datadir.mjs'
+
+/** 本仓库根（注册表加载器的默认 root；`--schedule-*` 才用得到）。 */
+const REPO_DIR = fileURLToPath(new URL('..', import.meta.url))
+
+// ── 判据（唯一口径；人话说明也在这一块，便于与 ~/.dsh/AGENTS.md 对齐）────────────
+export const CRITERION = {
+  rule: 'launchctl list 里 label 命中 flow-trigger 的数量：dev 档必须为 0；production 档必须恰好等于期望条数且 last exit 全 0、无 PAUSE_*',
+  source: '~/.dsh/AGENTS.md「机器角色：生产 = Huangwei 客户机；本机（chester Mac）不跑生产」',
+  // 允许清单用**模式**而不是把厂商/业务 label 抄进引擎（`vertical-lint` 的"引擎不掺业务"）：
+  // 引擎只认**功能**（宿主壳 dsh-web / 隧道 dsh-portforward / 保活 keepalive / 只读巡检），
+  // 具体 label 名由机器运行时提供（输出里照原样打印）。具体清单见 ~/.dsh/AGENTS.md「机器角色」。
+  allowedLabels: ['com.whyshu.dsh-web', 'com.whyshu.dsh-portforward'],
+  allowedLabelRe: /^com\.whyshu\.[a-z0-9-]*keepalive$/,
+  allowedNote: '本机只允许保留宿主壳（dsh-web）、端口转发（dsh-portforward）、保活类（*keepalive）与只读巡检类，见 ~/.dsh/AGENTS.md「机器角色」',
+  flowTriggerRe: /flow-trigger/i,
+  productionishRe: /(flow-timers|fulfillment|invoice-poll|poll-invoice|poll-fulfillment|argent-bridge|daily-report)/i,
+  /** "与我们有关"的 label（其余的 com.apple.* 之类不逐条打印，只记数量）。 */
+  relevantRe: /(whyshu|argent|hermes|dsh)/i,
+  consequence: [
+    '台账是**每机独立文件**、lease **没有跨机互斥** ⇒ 本机与客户机同跑**必然抢同一批生产行**。',
+    '2026-10-02 实测事故：本机的 4 个 flow-trigger 被重新拉起后，同 3 张日报票两机各自 `planned`。',
+  ],
+  correctAction: [
+    '生产只在客户机 Huangwei 上跑；迁移/回滚时"先起目标端 → 立刻停另一端 → 盯一个完整周期"。',
+    '本机要手工试跑：单独执行 runner（默认 dry-run），**不要**靠 cron/launchd。',
+    '⛔ 绝不在本机 `launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/com.whyshu.flow-trigger-*.plist`。',
+    '要停掉本机某个触发器：由**人工**决定并执行 `launchctl bootout`（本门禁只报告，不代劳）。',
+  ],
+  productionCorrectAction: [
+    '客户机（生产）应当**全活**：flow-trigger 恰好 N 条在册、launchd 加载、last exit 全 0、**没有** PAUSE_* 开关。',
+    '条数不对/有失败退出码 ⇒ 先在客户机上 `launchctl list | grep flow-trigger` 看实际状态与 last exit。',
+    '有 PAUSE_* ⇒ 该流程的生产跑批被开关挡住（客户机应保持全活；处置由人工决定）。',
+    '⛔ 本门禁只报告：不改 launchd、不动开关、不删文件。',
+  ],
+}
+
+/**
+ * 角色档（**唯一口径**；`--role` 选档，缺省 dev = 与旧版逐字兼容）。
+ * production 的期望条数**是数字不是名单**（缺省 4 = 客户机实测在册的 4 条生产流程；具体是哪些
+ * **见 `~/.dsh/AGENTS.md`「机器角色」，不抄进这里**）—— 引擎只认功能、不掺业务（`vertical-lint` 的
+ * engine-words 规则），"在册"由机器侧 `~/Library/LaunchAgents` 的 plist 对齐。
+ */
+export const ROLES = {
+  dev: {
+    id: 'dev', title: '开发机（本机 chester Mac）', expectedFlowTriggers: 0, expectAllAlive: false,
+    rule: 'launchctl list 里 label 命中 flow-trigger 的数量必须为 0',
+    okText: 'flow-trigger 计数 = 0（正确姿态）',
+  },
+  production: {
+    id: 'production', title: '生产机（客户机 Huangwei）', expectedFlowTriggers: 4, expectAllAlive: true,
+    rule: 'launchctl list 里 label 命中 flow-trigger 的数量必须**恰好等于期望条数**，且 last exit code 全 0、无 PAUSE_* 开关',
+    okText: 'flow-trigger 恰好 N 条在册、last exit 全 0、无 PAUSE_*（生产机正确姿态）',
+  },
+}
+export const ROLE_IDS = Object.keys(ROLES)
+
+/** 唯一允许的 launchctl 调用（常量冻结：本脚本永远只会 `launchctl list`）。 */
+export const LAUNCHCTL_ARGV = Object.freeze(['list'])
+
+// ── 参数 ────────────────────────────────────────────────────────────────────
+const USAGE = 'node scripts/check-production-home.mjs [--role dev|production] [--expect-flow-triggers <N>] [--strict] [--json] '
+  + '[--launchctl-output <file>] [--data-dir <dir>] [--launchagents-dir <dir>] '
+  + '[--no-schedule] [--schedule-online] [--dsh-home <dir>] [--base <url>]'
+const argv = process.argv.slice(2)
+const has = (f) => argv.includes(f)
+const val = (f) => {
+  const i = argv.indexOf(f)
+  return i > -1 ? argv[i + 1] : undefined
+}
+/** 取值型开关：它们的**值**不参与"未知参数"判定（否则 `--expect-flow-triggers 4` 会被误判）。 */
+const VALUE_FLAGS = new Set(['--launchctl-output', '--data-dir', '--launchagents-dir', '--role', '--expect-flow-triggers',
+  '--dsh-home', '--base'])
+const KNOWN = new Set(['--strict', '--json', '--help', '-h', '--no-schedule', '--schedule-online', ...VALUE_FLAGS])
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i]
+  if (VALUE_FLAGS.has(a)) { i++; continue }   // 跳过它的值（值缺失由下面逐项报错，判据不在这里）
+  if (a.startsWith('-') && !KNOWN.has(a)) {
+    console.error(`未知参数：${a}\n用法：${USAGE}`)
+    process.exit(2)
+  }
+}
+if (has('--help') || has('-h')) {
+  // 打印**整段**文档注释（到闭合行为止）：旧的 `slice(1, 34)` 会把后加的用法/退出码截掉
+  const src = readFileSync(new URL(import.meta.url), 'utf8').split('\n')
+  const end = src.findIndex((l, i) => i > 0 && /^\s*\*\/\s*$/.test(l))
+  console.log(src.slice(1, end > 0 ? end : 34).map((l) => l.replace(/^ \* ?/, '')).join('\n'))
+  process.exit(0)
+}
+
+const AS_JSON = has('--json')
+const STRICT = has('--strict')
+
+const outFile = val('--launchctl-output')
+const explicitDataDir = val('--data-dir')
+const explicitAgentsDir = val('--launchagents-dir')
+if (outFile !== undefined && !outFile) { console.error('--launchctl-output 需要一个文件路径'); process.exit(2) }
+if (explicitDataDir !== undefined && !explicitDataDir) { console.error('--data-dir 需要一个目录路径'); process.exit(2) }
+if (explicitAgentsDir !== undefined && !explicitAgentsDir) { console.error('--launchagents-dir 需要一个目录路径'); process.exit(2) }
+
+// ── 角色档（`--role`；缺省 dev = 向后兼容）───────────────────────────────────
+const roleFlag = val('--role')
+const expectFlag = val('--expect-flow-triggers')
+if (has('--role')) {
+  if (!roleFlag || roleFlag.startsWith('-')) { console.error(`--role 需要一个值（${ROLE_IDS.join('|')}）\n用法：${USAGE}`); process.exit(2) }
+  if (!ROLE_IDS.includes(roleFlag)) { console.error(`未知角色：${roleFlag}（可用：${ROLE_IDS.join('、')}）\n用法：${USAGE}`); process.exit(2) }
+}
+let expectedFlowTriggers = null
+if (has('--expect-flow-triggers')) {
+  if (!expectFlag || !/^\d+$/.test(String(expectFlag))) {
+    console.error(`--expect-flow-triggers 需要一个非负整数（实得 ${expectFlag === undefined ? '（缺值）' : expectFlag}）\n用法：${USAGE}`)
+    process.exit(2)
+  }
+  expectedFlowTriggers = Number(expectFlag)
+}
+if (roleFlag === 'dev' && expectedFlowTriggers !== null && expectedFlowTriggers !== 0) {
+  console.error(`--role dev 与 --expect-flow-triggers ${expectedFlowTriggers} 矛盾：开发机档要求 **0 条**`
+    + `（要按生产机判请用 --role production）\n用法：${USAGE}`)
+  process.exit(2)
+}
+// 给了 `--expect-flow-triggers` 而没给 `--role` ⇒ 按**生产机**档判（"我说了期望条数"本身就是生产语义）
+const ROLE = expectedFlowTriggers === null
+  ? ROLES[roleFlag || 'dev']
+  : { ...ROLES[roleFlag || 'production'], expectedFlowTriggers }
+const IS_PRODUCTION = ROLE.expectAllAlive === true
+
+// ── 取证据（**只读**）────────────────────────────────────────────────────────
+
+/** 跑 `launchctl list`（唯一的 launchctl 调用；参数是冻结常量，不存在第二条路径）。 */
+export function readLaunchctl() {
+  const r = spawnSync('launchctl', [...LAUNCHCTL_ARGV], { encoding: 'utf8' })
+  if (r.error) return { ok: false, text: '', why: `launchctl 起不来：${r.error.code || r.error.message}` }
+  if (r.status !== 0) return { ok: false, text: String(r.stdout || ''), why: `launchctl list 退出码 ${r.status}（非 macOS 或受限环境）` }
+  return { ok: true, text: String(r.stdout || ''), why: '' }
+}
+
+/** `launchctl list` 文本 → 行表。表头（`PID Status Label`）与空行跳过；无法解析的行忽略。 */
+export function parseLaunchctlList(text) {
+  const rows = []
+  for (const line of String(text || '').split('\n')) {
+    const t = line.trim()
+    if (!t) continue
+    const cols = t.split(/\s+/)
+    if (cols.length < 3) continue
+    if (/^PID$/i.test(cols[0])) continue
+    const [pid, status, ...rest] = cols
+    rows.push({ pid: pid === '-' ? null : (Number(pid) || null), status: Number(status) || 0, label: rest.join(' ') })
+  }
+  return rows
+}
+
+/**
+ * 本机 LaunchAgents 里**存在**的 flow-trigger plist（只读目录名；不解析内容、不加载）。
+ * ⚠️ 这是**磁盘在册**清单，与"**已加载**"（`launchctl list` 的实测状态）是两件事 ——
+ * 2026-10-04 修正：旧版把在册但**已加载**的也印成"未加载"，在客户机上误报。
+ */
+export const DEFAULT_AGENTS_DIR = join(homedir(), 'Library', 'LaunchAgents')
+export function flowTriggerPlistsOnDisk(dir = DEFAULT_AGENTS_DIR) {
+  try {
+    if (!existsSync(dir)) return []
+    return readdirSync(dir).filter((n) => CRITERION.flowTriggerRe.test(n) && n.endsWith('.plist')).sort()
+  } catch { return [] }
+}
+
+/** LaunchAgents 目录的**可读性**（判"在册/不在册"必须有基准：目录读不到时**不**下"不在册"的结论）。 */
+export function agentsDirState(dir = DEFAULT_AGENTS_DIR) {
+  try { return { dir, readable: true, exists: existsSync(dir), plists: flowTriggerPlistsOnDisk(dir) } }
+  catch { return { dir, readable: false, exists: false, plists: [] } }
+}
+
+/** 数据目录里存在的 `PAUSE_*` 遗留开关（只读；用来判断"已加载的生产定时器是不是被开关挡住了"）。 */
+export function pauseSwitches(dataDir) {
+  try {
+    if (!dataDir || !existsSync(dataDir)) return []
+    return readdirSync(dataDir).filter((n) => n.startsWith('PAUSE_')).sort()
+  } catch { return [] }
+}
+
+/**
+ * 判定（纯函数，便于夹具回归）。
+ * @param {Array} rows `launchctl list` 行表（`{pid, status, label}`；`status` = **last exit code**）
+ * @param {object} [opts]
+ * @param {string[]} [opts.plistsOnDisk] 磁盘**在册**的 flow-trigger plist 文件名（含 `.plist`）
+ * @param {boolean} [opts.agentsDirReadable] 在册清单是否**可信**（目录读不到 ⇒ 不下"不在册"的结论）
+ * @param {string[]} [opts.pauseOnDisk] 数据目录里的 `PAUSE_*` 开关
+ * @param {object} [opts.role] 角色档（缺省 `ROLES.dev`；`ROLES.production` 是**相反**的期望）
+ * @returns {{findings: Array, flowTriggers: Array, productionish: Array, allowed: Array, others: Array, system: Array}}
+ */
+export function judge(rows, {
+  plistsOnDisk = [], agentsDirReadable = true, pauseOnDisk = [], evidenceOk = true, evidenceWhy = '', role = ROLES.dev,
+} = {}) {
+  const findings = []
+  const flowTriggers = rows.filter((r) => CRITERION.flowTriggerRe.test(r.label))
+  const allowed = rows.filter((r) => CRITERION.allowedLabels.includes(r.label) || CRITERION.allowedLabelRe.test(r.label))
+  const productionish = rows.filter((r) => !CRITERION.flowTriggerRe.test(r.label) && CRITERION.productionishRe.test(r.label))
+  const others = rows.filter((r) => CRITERION.relevantRe.test(r.label)
+    && !flowTriggers.includes(r) && !allowed.includes(r) && !productionish.includes(r))
+  const system = rows.filter((r) => !CRITERION.relevantRe.test(r.label))
+
+  // 在册判据：plist 文件名（去掉 `.plist`）= label 约定
+  const onDiskLabels = new Set(plistsOnDisk.map((n) => String(n).replace(/\.plist$/i, '')))
+  const onDiskLoaded = plistsOnDisk.filter((n) => flowTriggers.some((r) => r.label === String(n).replace(/\.plist$/i, '')))
+  const onDiskNotLoaded = agentsDirReadable ? plistsOnDisk.filter((n) => !onDiskLoaded.includes(n)) : []
+  const notOnDisk = agentsDirReadable ? flowTriggers.filter((r) => !onDiskLabels.has(r.label)) : []
+
+  if (role.expectAllAlive) {
+    // ── 生产档（客户机）：**恰好 N 条且全活**（数量/退出码是硬判据；在册、开关是告警）──
+    const n = flowTriggers.length
+    const want = role.expectedFlowTriggers
+    if (evidenceOk && n !== want) {
+      findings.push({
+        level: 'fail', label: `(flow-trigger 计数 ${n} ≠ 期望 ${want})`, pid: null,
+        why: `生产机应**恰好加载 ${want} 条** flow-trigger（多一条=多跑，少一条=生产缺岗）；`
+          + `实际 ${n} 条：${flowTriggers.map((r) => r.label).join('、') || '（无）'}`
+          + (onDiskNotLoaded.length ? `；磁盘在册但未加载 ${onDiskNotLoaded.length} 个` : ''),
+      })
+    }
+    for (const r of flowTriggers) {
+      if (r.status !== 0) {
+        findings.push({
+          level: 'fail', label: r.label, pid: r.pid,
+          why: `last exit code = ${r.status}（≠0）—— 该触发器在**失败循环**里，生产跑批事实上没在跑`,
+        })
+      }
+    }
+    for (const p of onDiskNotLoaded) {
+      findings.push({ level: 'warn', label: p, pid: null, why: '磁盘在册但**未加载**：生产机应保持**全活**（该流程当前没有在跑）' })
+    }
+    for (const r of notOnDisk) {
+      findings.push({
+        level: 'warn', label: r.label, pid: r.pid,
+        why: `已加载但**不在册**（LaunchAgents 目录里找不到同名 plist）⇒ 来源不明，人工确认它是什么`,
+      })
+    }
+    for (const p of pauseOnDisk) {
+      findings.push({
+        level: 'warn', label: p, pid: null,
+        why: '数据目录里有 **PAUSE_\*** 开关：客户机（生产）应保持**全活** —— 有开关 = 该流程的生产跑批被挡住'
+          + '（含义：`PAUSE_*` 是本机/旧装机遗留的暂停开关，客户机不该带着它跑生产）',
+      })
+    }
+  } else {
+    // ── 开发档（**与 2026-10-03 版逐字一致**）：本机一条都不许有 ──
+    for (const r of flowTriggers) {
+      findings.push({ level: 'fail', label: r.label, pid: r.pid, why: '本机**加载了** flow-trigger：生产触发器必须只在客户机 Huangwei 上跑' })
+    }
+    // disk 上存在**且没加载** ⇒ 只提示"现成弹药"（已加载的**不在此列**：它已被上面的 fail 覆盖）
+    for (const p of onDiskNotLoaded) {
+      findings.push({ level: 'info', label: p, pid: null, why: '磁盘上存在该 flow-trigger plist 但**未加载**（正确姿态）；它是 bootstrap 的现成弹药，别碰' })
+    }
+  }
+  for (const r of productionish) {
+    findings.push({
+      level: 'warn', label: r.label, pid: r.pid,
+      why: '名字像**生产型调度器**（poll/invoice/fulfillment/flow-timers/daily-report）—— 与 flow-trigger 同一类"双跑"风险',
+    })
+  }
+  if (!evidenceOk) {
+    findings.push({ level: 'warn', label: '(证据不足)', pid: null, why: `${evidenceWhy || 'launchctl 不可用'} ⇒ **不能证明**本机姿态正确（"查不到" ≠ "干净"）` })
+  }
+  return { findings, flowTriggers, productionish, allowed, others, system, onDiskLoaded, onDiskNotLoaded, notOnDisk }
+}
+
+// ── 主流程 ──────────────────────────────────────────────────────────────────
+const source = outFile ? `--launchctl-output ${outFile}` : 'launchctl list'
+let ev = { ok: !outFile, text: '', why: '' }
+if (outFile) {
+  try {
+    ev = { ok: true, text: readFileSync(outFile, 'utf8'), why: '' }
+  } catch (e) {
+    console.error(`--launchctl-output 读不了：${outFile}（${e.message}）`)
+    process.exit(2)
+  }
+} else {
+  ev = readLaunchctl()
+}
+const rows = parseLaunchctlList(ev.text)
+const dataDir = explicitDataDir || resolveDataDir({ env: process.env }).dir
+const agents = agentsDirState(explicitAgentsDir || DEFAULT_AGENTS_DIR)
+const plists = agents.plists
+const pauses = pauseSwitches(dataDir)
+// "证据不足" = launchctl 跑不起来 **或** 输出解析不出任何行
+const evidenceOk = ev.ok && rows.length > 0
+const verdict = judge(rows, {
+  plistsOnDisk: plists, agentsDirReadable: agents.readable, pauseOnDisk: pauses,
+  evidenceOk, evidenceWhy: ev.why || '输出里没有任何可解析的 launchctl 行', role: ROLE,
+})
+/** 计数判据的结论（生产档 = 恰好 N 条；开发档 = 0 条）—— 单独算，便于人话与 JSON 共用。 */
+const countOk = evidenceOk && verdict.flowTriggers.length === ROLE.expectedFlowTriggers
+
+// ── 排程面体检（P1-A，2026-10-12；只读；**永不计入 fail**）────────────────────
+// 判据 = `scripts/lib/schedule-probe.mjs` 的四道闸（⚠️ 同一份实现，⛔ 这里不另写一套）。
+const NO_SCHEDULE = has('--no-schedule')
+const SCHEDULE_ONLINE = has('--schedule-online')
+const DSH_HOME_FLAG = val('--dsh-home')
+const SCHEDULE_BASE = (val('--base') || 'http://127.0.0.1:3080').replace(/\/+$/, '')
+
+/** 注册表里的 `trigger.schedule` 声明（读不到 ⇒ 如实说"读不到"，不静默当"没声明"）。 */
+async function scheduleDeclarations() {
+  try {
+    const { loadRegistryDoc } = await import('./lib/registry.mjs')
+    const doc = loadRegistryDoc({ root: REPO_DIR })
+    return {
+      declared: Object.entries(doc.flows || {})
+        .map(([id, spec]) => ({ id, schedule: spec && spec.trigger && spec.trigger.schedule, trigger: (spec && spec.trigger) || {} }))
+        .filter((x) => x.schedule && typeof x.schedule === 'object'),
+      error: '',
+    }
+  } catch (e) {
+    return { declared: [], error: String((e && (e.stderr || e.message)) || e).split('\n')[0] }
+  }
+}
+
+async function scheduleFace() {
+  if (NO_SCHEDULE) return { enabled: false, mode: 'off', gates: [], level: 'info', mounted: null, declared: [], lines: [] }
+  const probe = await import('./lib/schedule-probe.mjs')
+  const paths = probe.domainPaths(probe.storageRoot({ dshHome: DSH_HOME_FLAG || undefined }))
+  const inspection = probe.inspectDomain(paths)
+  const gates = [probe.gatePersistence(inspection, { backupRoots: [join(dataDir, 'backup'), join(dataDir, 'backups')] })]
+  const { declared, error: regError } = await scheduleDeclarations()
+  const enabledDecls = declared.filter((d) => d.schedule.enabled === true)
+  let mounted = null
+  if (SCHEDULE_ONLINE) {
+    const { authSources, acquireWakeAuth } = await import('./lib/wake-auth.mjs')
+    const auth = await acquireWakeAuth({
+      sources: authSources({ base: SCHEDULE_BASE, env: process.env, dshHome: DSH_HOME_FLAG || undefined }),
+      base: SCHEDULE_BASE,
+    })
+    const res = auth.ok
+      ? await probe.postRpc({ base: SCHEDULE_BASE, endpoint: probe.MOUNT_ENDPOINT, args: {}, cookie: auth.cookie })
+      : { state: 'unauthorized', httpStatus: 0, message: auth.unreachable || '鉴权链全部失败（详见 argent-schedule probe）' }
+    const mountGate = probe.gateMount(res)
+    mounted = mountGate.state === 'green'
+    gates.push(mountGate)
+    const entries = (res && res.state === 'ok' && Array.isArray(res.value)) ? res.value.map(probe.normalizeEntry).filter(Boolean) : null
+    if (entries && enabledDecls.length) {
+      const nowMs = Date.now()
+      for (const d of enabledDecls) {
+        const localId = String(d.id).split('.').pop()
+        const m = probe.matchTask(entries, { flowId: d.id, alternatives: [localId], taskTitle: String(d.schedule.taskTitle || '') })
+        const e = m.entry
+        gates.push(probe.gateFreshness({ entry: e, nowMs, periodSec: e ? probe.periodSecondsOf(e) : null, label: d.id }))
+        const ev = probe.readL1Evidence({
+          logPath: d.trigger.log ? join(dataDir, String(d.trigger.log)) : '',
+          ledgerPath: join(dataDir, 'flow-ledger.jsonl'),
+          flowIds: [d.id, localId],
+        })
+        gates.push(probe.gateExecution({ entry: e, evidence: ev, nowMs, label: d.id }))
+      }
+    }
+  }
+  // 严重度**上限 = warn**（且未挂载时的红降为 info —— 那是"声明已就位、宿主未挂载/未建任务"的
+  // 过渡态，不是故障；P1-B 落地前它会一直是这个形态）：
+  const reds = gates.filter((g) => g.state === 'red')
+  const persistRed = gates.some((g) => g.gate === 'persistence' && g.state === 'red')
+  const level = (reds.length && (mounted || persistRed)) ? 'warn' : 'info'
+  return {
+    enabled: true,
+    mode: SCHEDULE_ONLINE ? 'online' : 'offline',
+    gates, level, mounted, declared: declared.map((d) => d.id), enabledDecls: enabledDecls.map((d) => d.id),
+    registryError: regError,
+    domainState: inspection.state, domainPaths: paths, domainFiles: inspection.files.map((f) => f.path),
+    base: SCHEDULE_BASE,
+  }
+}
+
+const schedule = await scheduleFace()
+if (schedule.level === 'warn') {
+  const g = schedule.gates.filter((x) => x.state === 'red')
+  verdict.findings.push({
+    level: 'warn', label: '(排程面)', pid: null,
+    why: `${g.map((x) => `[${x.gate}] ${x.headline}`).join('；')}`
+      + ' —— 排程面**最高只判 warn**（真正的判红归 `node scripts/argent-schedule.mjs check`，exit 0/1/2）',
+  })
+}
+
+// `failed`/`warned` **在排程面之后**才算：排程面的 warn 同样受 `--strict` 约束（它只在
+// "宿主已挂载但某道闸红"或"域文件坏了"时出现 —— 那都是真问题，不是过渡态）。
+const failed = verdict.findings.some((f) => f.level === 'fail')
+const warned = verdict.findings.some((f) => f.level === 'warn')
+
+const human = []
+human.push(`🔎 生产归属检查（角色 **${ROLE.id}** = ${ROLE.title}）`)
+human.push('')
+human.push(`  判据：${ROLE.rule}`)
+human.push(`  出处：${CRITERION.source}`)
+human.push(`  证据：${source}${outFile ? '' : `（${rows.length} 行）`}`)
+human.push('')
+if (ROLE.expectAllAlive) {
+  if (!evidenceOk) {
+    human.push('  ⚠️ 证据不足：无法确认 flow-trigger 计数（**不能**当成"符合期望"）。')
+    human.push(`     ${ev.why || '输出里没有任何可解析的 launchctl 行'}`)
+  } else if (countOk && !failed) {
+    human.push(`  ✅ flow-trigger 恰好 ${ROLE.expectedFlowTriggers} 条、last exit 全 0`
+      + `${pauses.length ? `（⚠ 但数据目录有 ${pauses.length} 个 PAUSE_* 开关，见下）` : '、无 PAUSE_*'}。`)
+    for (const r of verdict.flowTriggers) human.push(`     · ${r.label.padEnd(34)} ${r.pid ? `PID ${r.pid}` : '未运行'}  last exit ${r.status}`)
+  } else {
+    human.push(`  ${failed ? '❌' : '⚠️'} flow-trigger 计数 = ${verdict.flowTriggers.length}（期望**恰好 ${ROLE.expectedFlowTriggers} 条**）`
+      + `${failed ? ' —— **姿态不符**：' : ''}`)
+    for (const r of verdict.flowTriggers) {
+      human.push(`     · ${r.label.padEnd(34)} ${r.pid ? `PID ${r.pid}` : '未运行'}  last exit ${r.status}${r.status !== 0 ? '  ← 失败退出码' : ''}`)
+    }
+    if (!verdict.flowTriggers.length) human.push('     （一条都没有：生产机应全活）')
+    if (verdict.onDiskNotLoaded.length) {
+      human.push(`     磁盘在册但**未加载**（${verdict.onDiskNotLoaded.length} 个）：${verdict.onDiskNotLoaded.join(', ')}`)
+    }
+  }
+} else {
+  if (failed) {
+    human.push(`  ❌ 本机加载了 ${verdict.flowTriggers.length} 个 flow-trigger —— **姿态错误**：`)
+    for (const r of verdict.flowTriggers) human.push(`     · ${r.label}${r.pid ? `（PID ${r.pid}）` : ''}`)
+  } else if (!evidenceOk) {
+    human.push('  ⚠️ 证据不足：无法确认本机 flow-trigger 计数（**不能**当成"干净"）。')
+    human.push(`     ${ev.why || '输出里没有任何可解析的 launchctl 行'}`)
+  } else {
+    human.push(`  ✅ ${ROLE.okText}。`)
+  }
+}
+human.push('')
+human.push(`  相关 LaunchAgent（允许：${CRITERION.allowedLabels.join(' / ')} / *keepalive / 只读巡检）：`)
+if (!rows.length) human.push('     （没有读到任何 launchd 行）')
+for (const r of verdict.allowed) human.push(`     · ${r.label.padEnd(34)} ${r.pid ? `PID ${r.pid}` : '未运行'}`)
+for (const r of verdict.productionish) human.push(`     ⚠️ ${r.label.padEnd(31)} ${r.pid ? `PID ${r.pid}` : '未运行'}  ← 生产型调度器`)
+for (const r of verdict.others) human.push(`     · ${r.label.padEnd(34)} ${r.pid ? `PID ${r.pid}` : '未运行'}`)
+human.push(`     （其余 ${verdict.system.length} 个系统/无关 label 不逐条打印）`)
+if (plists.length) {
+  human.push('')
+  // ⚠️ 磁盘在册 ≠ 未加载：这里**只**列"在册但没在 launchctl list 里"的那些（已加载的走上面的计数/状态）
+  human.push(`  ℹ️ 磁盘在册的 flow-trigger plist：${plists.length} 个 —— 其中**已加载** ${verdict.onDiskLoaded.length} 个、`
+    + `**未加载** ${verdict.onDiskNotLoaded.length} 个${agents.readable ? '' : '（⚠ LaunchAgents 目录读不到，"在册"判据不可信）'}：`)
+  for (const p of plists) {
+    const label = String(p).replace(/\.plist$/i, '')
+    const loaded = verdict.onDiskLoaded.includes(p)
+    human.push(`     · ${label.padEnd(34)} ${loaded ? '已加载（见上面的计数/状态）' : '未加载（正确姿态；别 bootstrap）'}`)
+  }
+  if (verdict.notOnDisk.length) {
+    human.push(`     ⚠️ 已加载但**不在册**（磁盘上找不到同名 plist）：${verdict.notOnDisk.map((r) => r.label).join(', ')}`)
+  }
+}
+if (pauses.length) {
+  human.push('')
+  human.push(`  ${ROLE.expectAllAlive ? '⚠️' : 'ℹ️'} 数据目录里的开关（${dataDir}）：${pauses.join(', ')}`)
+  human.push(ROLE.expectAllAlive
+    ? '     —— 客户机（生产）应保持**全活**：有 `PAUSE_*` = 该流程的生产跑批被挡住（该开关本是本机/旧装机遗留，别让它留在生产机上）。'
+    : '     —— 已加载的生产定时器**可能**被它挡住；但"挡住"不等于"不该加载"，仍应按机器角色清理（由人工决定）。')
+}
+if (schedule.enabled) {
+  human.push('')
+  human.push(`  ── 排程面（P1-A；只读；最高 warn，**从不 fail**）｜模式 ${schedule.mode}｜域文件 ${schedule.domainState}`)
+  if (schedule.registryError) human.push(`     ⚠️ 注册表读不到（不静默当"没声明"）：${schedule.registryError}`)
+  if (!schedule.declared.length && !schedule.registryError) human.push('     ℹ️ 没有任何流程声明 `trigger.schedule` ⇒ 排程面未启用')
+  else if (schedule.declared.length) {
+    human.push(`     ℹ️ 声明了 trigger.schedule 的流程：${schedule.declared.length} 条｜其中 enabled=true：${schedule.enabledDecls.join('、') || '（无）'}`)
+  }
+  if (!SCHEDULE_ONLINE) {
+    human.push('     ℹ️ 离线档：只查域文件与声明面；要跑①②③三闸（宿主 HTTP + 唤醒凭据）加 `--schedule-online`')
+  }
+  const sum = (await import('./lib/schedule-probe.mjs')).summarize(schedule.gates)
+  human.push((await import('./lib/schedule-probe.mjs')).formatGates(sum, { prefix: '     ' }))
+  human.push(`     ↳ 完整判据与红线：\`node scripts/argent-schedule.mjs check\`（exit 0 全绿 / 1 有红 / 2 证据不足）`)
+}
+if (failed || warned) {
+  human.push('')
+  human.push('  ⛔ 后果：')
+  for (const c of CRITERION.consequence) human.push(`     · ${c}`)
+  human.push('  ✅ 正确做法：')
+  for (const c of ROLE.expectAllAlive ? CRITERION.productionCorrectAction : CRITERION.correctAction) human.push(`     · ${c}`)
+}
+human.push('')
+human.push(`  结论（${ROLE.id} 档）：${failed ? '❌ 与机器角色不符（必须人工处理）' : warned ? '⚠️ 有告警（请人工确认）' : '✅ 姿态正确'}`
+  + `（本检查**只报告**，不改 launchd；${STRICT ? '--strict ⇒ 有 fail/warn 时 exit 1' : '默认恒 exit 0，--strict 时才非零'}）`)
+
+const payload = {
+  ok: !failed && !warned,
+  tool: 'check-production-home',
+  role: ROLE.id,
+  roleTitle: ROLE.title,
+  expectedFlowTriggers: ROLE.expectedFlowTriggers,
+  countOk,
+  criterion: ROLE.rule,
+  criterionSource: CRITERION.source,
+  evidence: { source, rows: rows.length, launchctlOk: ev.ok, why: ev.why || '' },
+  counts: {
+    flowTriggers: verdict.flowTriggers.length,
+    productionish: verdict.productionish.length,
+    allowed: verdict.allowed.length,
+    others: verdict.others.length,
+    plistsOnDisk: plists.length,
+    plistsLoaded: verdict.onDiskLoaded.length,
+    plistsNotLoaded: verdict.onDiskNotLoaded.length,
+    notOnDisk: verdict.notOnDisk.length,
+  },
+  flowTriggerLabels: verdict.flowTriggers.map((r) => r.label),
+  flowTriggerStatus: verdict.flowTriggers.map((r) => ({ label: r.label, pid: r.pid, lastExit: r.status })),
+  plistsOnDisk: { all: plists, loaded: verdict.onDiskLoaded, notLoaded: verdict.onDiskNotLoaded, dirReadable: agents.readable },
+  findings: verdict.findings,
+  pauseSwitches: pauses,
+  dataDir,
+  // 排程面体检（P1-A）：字段与判据同源（lib/schedule-probe.mjs）；⛔ 它**不参与** failed/warned 的
+  // 计算，除非它自己判了 warn（见上面那段说明）。
+  schedule: schedule.enabled
+    ? {
+      mode: schedule.mode, level: schedule.level, mounted: schedule.mounted, base: schedule.base,
+      declared: schedule.declared, enabledFlows: schedule.enabledDecls,
+      registryError: schedule.registryError || '',
+      domain: { state: schedule.domainState, paths: schedule.domainPaths, files: schedule.domainFiles },
+      gates: schedule.gates,
+    }
+    : { mode: 'off' },
+}
+
+if (AS_JSON) console.log(JSON.stringify(payload, null, 2))
+else console.log(human.join('\n'))
+
+const bad = failed || warned
+process.exit(STRICT && bad ? 1 : 0)