@things-factory/headless-twin 10.0.19 → 10.1.0

package/server/service/actuation/rule-evaluate.ts

@@ -0,0 +1,352 @@
+/*
+ * **관측에서 조치를 낸다** — 그 판정 하나.
+ *
+ * ── 무엇이 없었나 (2026-09-01) ───────────────────────────────────────────
+ * 승인 게이트를 세우고 나니 **낼 수 있는 것이 사람뿐**이었다. 계약은 낸 쪽을 네 가지로 두는데
+ * (`operator` · `rule` · `ai` · `schedule`) 사람 말고는 길이 없었다. 게이트의 값어치는 트윈이 스스로
+ * 알아챈 것을 사람이 판단하는 데 있는데, 알아챈 것을 올릴 자리가 없었다.
+ *
+ * ── 조건을 새로 만들지 않는다 ────────────────────────────────────────────
+ * 커널이 이미 상태에서 「봐야 할 것」을 판단해 `Attention` 으로 낸다 — 안정된 종류 코드(`kind`),
+ * 무엇에 대한 것인지(`anchor`), 언제부터인지(`timeStamp`), 표현용 값(`params`). 조건 언어를 새로 만들면
+ * 같은 판단이 두 벌이 되고, 한쪽만 고쳐지는 날이 온다.
+ *
+ * 그래서 규칙은 **어느 주의에 어느 지시를 붙이는가**만 정한다.
+ *
+ * ── 자극과 지시를 잇지 않는다 ────────────────────────────────────────────
+ * 주의에는 `suggestedAction.command` 가 실려 있지만 그것은 **커널 안에서 도는 자극**이다
+ * (`resource.repair` = 모델에서 수리된 것으로 둔다). 여기서 내는 것은 현장에 나가는 지시다. 그 값을
+ * 그대로 쓰면 「모델을 그렇게 두라」가 「사람을 보내라」가 된다(§`propose` 의 거절).
+ *
+ * ── 무너지는 것 넷 ───────────────────────────────────────────────────────
+ * 행복한 길은 짧다. 실제로 무너지는 것은 이것들이다.
+ *
+ *   같은 조건이 매 주기 다시 올라온다   대기 줄에 같은 지시가 수십 개 선다
+ *   방금 생긴 조건에 바로 올린다        깜빡인 것에 현장 지시가 나간다
+ *   조건이 사라진 뒤에도 대기에 남는다  승인하는 사람이 없는 문제를 판단한다
+ *   한 번에 수백 개가 올라온다          사람이 읽을 수 없고, 읽지 않으면 게이트가 시늉이 된다
+ *
+ * 넷 다 오류가 나지 않는다. 그래서 이 파일이 넷을 다룬다.
+ */
+import type { CommandTypeSpec } from '@operato/ops-contract'
+
+/** 어느 주의에 어느 지시를 붙이는가 — 선언 한 줄. */
+export interface ActuationRuleSpec {
+  id: string
+  /** 이 트윈에만 적용된다. 트윈마다 라인이 다르므로 전역 규칙은 두지 않는다. */
+  instanceId: string
+  /** 어느 주의인가 — 커널의 안정 코드(`Attention.kind`). */
+  attentionKind: string
+  /** 이 심각도 이상일 때만 — 없으면 종류만 본다. */
+  minSeverity?: 'low' | 'medium' | 'high' | 'critical'
+  /**
+   * **조건이 이만큼 이어졌을 때** 올린다.
+   *
+   * 없으면 처음 본 주기에 바로 올린다. 깜빡이는 조건에 현장 지시가 나가는 것을 막으려면 이 값이 필요하다
+   * — 커널이 조건이 처음 성립한 시각을 기억하므로(`Attention.timeStamp`) 여기서 잴 수 있다.
+   */
+  minHeldMs?: number
+  /** 무엇을 내는가 — 선언된 조치 종류(`CommandTypeSpec.type`). 커널 자극이 아니다. */
+  commandType: string
+  /**
+   * 지시의 내용 — `{이름}` 을 주의의 값으로 바꿔 넣는다.
+   *
+   * 바꿀 값은 `Attention.params` 와 `anchor` 에서 온다(`{locationId}` · `{ratioPct}`). 한 겹 중괄호를
+   * 쓰는 것은 이 저장소의 i18n 관례와 같다.
+   *
+   * 바꿀 것이 없으면 **그 자리를 비운다** — 지어낸 값을 넣지 않는다. 요구하는 칸이 비면 계약이 거절하고
+   * (§`missingCommandPayload`) 그 거절이 사람에게 전해진다.
+   */
+  payloadTemplate?: Record<string, unknown>
+  /**
+   * **한 번 낸 근거에 다시 내기까지 기다리는 시간.**
+   *
+   * 이것이 없으면 승인하는 순간 규칙이 같은 것을 또 낸다 — 실제로 그랬다. 「결정을 기다리는 것」만 보고
+   * 중복을 막았는데, 승인하면 그 커맨드가 대기에서 빠지고 조건은 그대로 서 있기 때문이다. 사람이
+   * 승인할수록 대기 줄이 다시 차는 모양이 된다.
+   *
+   * 조건은 이어지는 것이고 조치는 시간이 걸린다. 낸 조치가 효과를 낼 때까지 기다리는 시간이 이 값이다.
+   */
+  cooldownMs?: number
+  /** 꺼 둔 규칙은 판정하지 않는다. 지우지 않고 끌 수 있어야 한다. */
+  enabled?: boolean
+}
+
+/** 판정에 들어가는 주의 — 커널이 낸 모양 그대로 중 필요한 것만. */
+export interface AttentionLike {
+  id: string
+  kind: string
+  severity: string
+  state?: string
+  anchor?: { locationId?: string; moverId?: string; orderId?: string; operation?: string }
+  timeStamp?: string
+  params?: Record<string, string | number>
+}
+
+/** 올릴 것 하나. */
+export interface RuleProposal {
+  ruleId: string
+  attentionId: string
+  attentionKind: string
+  commandType: string
+  payload: Record<string, unknown>
+}
+
+/** 올리지 않은 것과 그 이유 — **말하지 않으면 사람은 규칙이 도는 줄 안다.** */
+export interface RuleSkip {
+  ruleId: string
+  attentionId?: string
+  reason: string
+}
+
+export interface RuleVerdict {
+  proposals: RuleProposal[]
+  /** 왜 안 올렸나. 조용히 넘어가지 않는다. */
+  skips: RuleSkip[]
+  /** 상한에 닿아 잘랐나 — 잘랐으면 몇 개를 두고 왔나. */
+  withheld?: number
+}
+
+const SEVERITY_ORDER = ['low', 'medium', 'high', 'critical'] as const
+
+/** 심각도가 문턱에 닿나 — 모르는 값은 닿지 않는 것으로 본다(모름을 통과로 읽지 않는다). */
+function severityMeets(actual: string, min: string | undefined): boolean {
+  if (!min) return true
+  const a = SEVERITY_ORDER.indexOf(actual as any)
+  const m = SEVERITY_ORDER.indexOf(min as any)
+  if (a < 0 || m < 0) return false
+  return a >= m
+}
+
+/**
+ * `{이름}` 을 바꿔 넣는다 — 바꿀 값이 없으면 **그 칸을 뺀다.**
+ *
+ * 원래 문자열을 그대로 두면 `{quantity}` 같은 글자가 지시의 수량으로 들어가고, 그 지시가 현장에 나간다.
+ * 빼면 계약이 「요구하는 칸이 없다」로 거절하고 그 거절이 사람에게 전해진다.
+ */
+function fill(template: Record<string, unknown> | undefined, values: Record<string, string | number>): {
+  payload: Record<string, unknown>
+  missing: string[]
+} {
+  const payload: Record<string, unknown> = {}
+  const missing: string[] = []
+  if (!template) return { payload, missing }
+
+  for (const [key, raw] of Object.entries(template)) {
+    if (typeof raw !== 'string') {
+      payload[key] = raw
+      continue
+    }
+
+    /* 값 하나를 그대로 나르는 자리 — 수를 문자열로 만들지 않는다(수량이 문자열이면 계산이 무너진다). */
+    const whole = /^\{([A-Za-z0-9_.]+)\}$/.exec(raw)
+    if (whole) {
+      const name = whole[1]!
+      if (!(name in values)) {
+        missing.push(name)
+        continue
+      }
+      payload[key] = values[name]
+      continue
+    }
+
+    let gap = false
+    const text = raw.replace(/\{([A-Za-z0-9_.]+)\}/g, (_m, name: string) => {
+      if (name in values) return String(values[name])
+      missing.push(name)
+      gap = true
+      return ''
+    })
+    if (!gap) payload[key] = text
+  }
+
+  return { payload, missing }
+}
+
+/** 바꿔 넣을 값 — 주의의 `params` 와 `anchor` 에서. */
+function valuesOf(attention: AttentionLike): Record<string, string | number> {
+  const out: Record<string, string | number> = { ...(attention.params ?? {}) }
+  for (const [key, value] of Object.entries(attention.anchor ?? {})) {
+    if (value !== undefined && value !== null && value !== '') out[key] = value as string
+  }
+  out.attentionId = attention.id
+  out.attentionKind = attention.kind
+  return out
+}
+
+/**
+ * 이번에 무엇을 올릴지 정한다 — **순수 함수**. 저장소도 시계도 보지 않는다.
+ *
+ * 시험이 재기동과 상한과 중복을 다 걸을 수 있어야 하고, 그러려면 이 판정이 밖에서 값을 받아야 한다.
+ * 이 저장소에서 가장 자주 나는 결함이 「자리는 있고 길이 없다」이고, 게이트에 물리는 것이므로 여기서
+ * 나면 결과가 현장의 지시다.
+ */
+export function evaluateRules(args: {
+  rules: readonly ActuationRuleSpec[]
+  attentions: readonly AttentionLike[]
+  /** 선언된 조치 종류 — 없는 종류를 가리키는 규칙은 여기서 걸린다. */
+  specs: readonly CommandTypeSpec[]
+  /**
+   * **이미 다루고 있는 근거들** — 근거마다 마지막으로 조치를 낸 시각.
+   *
+   * 결정을 기다리는 것만 보면 부족하다. 승인하는 순간 그 커맨드가 대기에서 빠지고 조건은 그대로
+   * 서 있어서, 다음 바퀴가 같은 것을 또 낸다 — 걸어 보고 그 상태를 실제로 만들었다.
+   *
+   * 그래서 **낸 시각**을 받는다. 결정을 기다리는 것은 시각과 무관하게 막는다(§`openCauses`).
+   * 저장소에서 읽어 넘긴다 — 프로세스 기억에 두면 재기동이 곧 중복이 된다.
+   */
+  openCauses: ReadonlySet<string>
+  /** 근거 → 마지막으로 조치를 낸 시각(ms). 없으면 낸 적이 없다. */
+  lastProposedAt?: ReadonlyMap<string, number>
+  /** 지금 — 조건이 얼마나 이어졌는지 재는 기준. */
+  nowMs: number
+  /** 한 번에 몇 개까지 올리나. 넘는 것은 두고 오고, 두고 온 수를 말한다. */
+  maxPerRun?: number
+}): RuleVerdict {
+  const { rules, attentions, specs, openCauses, nowMs } = args
+  const maxPerRun = args.maxPerRun ?? DEFAULT_MAX_PER_RUN
+
+  const proposals: RuleProposal[] = []
+  const skips: RuleSkip[] = []
+  let withheld = 0
+
+  /* 한 주의에 규칙이 둘 붙어 있어도 조치는 하나만 올린다 — 같은 조건에 두 지시가 나가면 현장이 두 번 움직인다. */
+  const claimed = new Set<string>(openCauses)
+
+  for (const rule of rules) {
+    if (rule.enabled === false) continue
+
+    const gap = commandTypeGap(rule.commandType, specs)
+    if (gap) {
+      skips.push({ ruleId: rule.id, reason: gap })
+      continue
+    }
+    const spec = specs.find(s => s.type === rule.commandType)!
+
+    for (const attention of attentions) {
+      if (attention.kind !== rule.attentionKind) continue
+
+      /* 확인된 것과 사라진 것에는 올리지 않는다 — 사람이 이미 본 것이다. */
+      if (attention.state && attention.state !== 'active') continue
+
+      if (!severityMeets(attention.severity, rule.minSeverity)) continue
+
+      if (claimed.has(attention.id)) continue
+
+      /*
+       * 낸 지 얼마 안 됐으면 기다린다. 조건은 이어지는 것이고 조치는 시간이 걸린다 — 효과를 보기 전에
+       * 또 내면 대기 줄이 같은 지시로 찬다.
+       */
+      const lastAt = args.lastProposedAt?.get(attention.id)
+      const cooldown = rule.cooldownMs ?? DEFAULT_COOLDOWN_MS
+      if (lastAt !== undefined && cooldown > 0 && nowMs - lastAt < cooldown) continue
+
+      const held = heldMs(attention, nowMs)
+      if (rule.minHeldMs && rule.minHeldMs > 0) {
+        if (held === undefined) {
+          /*
+           * 언제부터인지 모르는 주의다. **모름을 「충분히 오래됐다」로 읽지 않는다** — 그렇게 읽으면
+           * 방금 생긴 깜빡임에 현장 지시가 나간다.
+           */
+          skips.push({
+            ruleId: rule.id,
+            attentionId: attention.id,
+            reason: `이 주의는 언제부터인지 말하지 않는다 — ${rule.minHeldMs}ms 이어졌는지 알 수 없어 올리지 않았다`
+          })
+          continue
+        }
+        if (held < rule.minHeldMs) continue
+      }
+
+      if (proposals.length >= maxPerRun) {
+        withheld++
+        continue
+      }
+
+      const { payload, missing } = fill(rule.payloadTemplate, valuesOf(attention))
+      if (missing.length) {
+        skips.push({
+          ruleId: rule.id,
+          attentionId: attention.id,
+          reason: `지시에 넣을 값이 주의에 없다 (${[...new Set(missing)].join(', ')}) — 지어낸 값으로 현장 지시를 만들지 않았다`
+        })
+        continue
+      }
+
+      const gaps = missingRequired(spec, payload)
+      if (gaps.length) {
+        skips.push({
+          ruleId: rule.id,
+          attentionId: attention.id,
+          reason: `지시가 요구하는 칸이 비었다 (${gaps.join(', ')}) — 무엇을 지시하는지 모르면 승인할 근거가 없다`
+        })
+        continue
+      }
+
+      claimed.add(attention.id)
+      proposals.push({
+        ruleId: rule.id,
+        attentionId: attention.id,
+        attentionKind: attention.kind,
+        commandType: rule.commandType,
+        payload
+      })
+    }
+  }
+
+  return { proposals, skips, ...(withheld ? { withheld } : {}) }
+}
+
+/** 한 번에 올리는 상한 — 사람이 읽을 수 있는 수. 읽지 않는 대기 줄은 게이트가 아니다. */
+export const DEFAULT_MAX_PER_RUN = 20
+
+/**
+ * 같은 근거에 다시 내기까지 — **선언하지 않아도 기다린다.**
+ *
+ * 기본을 0 으로 두면 선언하지 않은 규칙이 승인할 때마다 같은 것을 또 낸다. 그 결함을 기본값으로 두지
+ * 않는다. 더 빨리 내야 하는 규칙은 스스로 짧게 적는다.
+ */
+export const DEFAULT_COOLDOWN_MS = 60 * 60_000
+
+/**
+ * 이 규칙이 낼 수 있는 종류인가 — **판정이 한 자리에만 있게.**
+ *
+ * 저장할 때와 돌 때가 같은 것을 봐야 한다. 두 벌이면 저장은 되는데 안 도는 규칙이 생기고, 사람은 규칙이
+ * 걸린 줄로 읽는다.
+ *
+ * `stimuli` 를 받는 이유: 커널 자극(`CMD`)을 적었을 때 **왜 안 되는지**를 말하려면 그 어휘를 알아야 한다.
+ * 「선언되지 않았다」로만 답하면 부르는 쪽은 선언이 빠진 줄로 읽고 선언을 추가한다 — 그 순간 모델 안의
+ * 자극이 현장 지시가 된다.
+ */
+export function commandTypeGap(
+  commandType: string,
+  specs: readonly CommandTypeSpec[],
+  stimuli?: readonly string[]
+): string | undefined {
+  if (specs.some(s => s.type === commandType)) return undefined
+
+  if (stimuli?.includes(commandType)) {
+    return (
+      `그것은 커널 안에서 도는 자극이다 (${commandType}) — 현장에 나가는 지시가 아니다. ` +
+      '모델 상태를 바꾸려면 커널에 자극을 넣고, 현장에 무언가를 시키려면 그 지시를 조치 종류로 선언한다'
+    )
+  }
+
+  return `선언되지 않은 조치 종류를 가리킨다 (${commandType}) — 선언된 것: ${specs.map(s => s.type).join(', ') || '(없음)'}`
+}
+
+/** 조건이 얼마나 이어졌나 — 모르면 `undefined`(0 이 아니다). */
+function heldMs(attention: AttentionLike, nowMs: number): number | undefined {
+  if (!attention.timeStamp) return undefined
+  const at = Date.parse(attention.timeStamp)
+  if (!Number.isFinite(at)) return undefined
+  return Math.max(0, nowMs - at)
+}
+
+/** 계약의 요구를 그대로 본다 — 판정을 여기서 다시 쓰지 않는다. */
+function missingRequired(spec: CommandTypeSpec, payload: Record<string, unknown>): string[] {
+  return (spec.required ?? []).filter(key => {
+    const v = payload[key]
+    return v === undefined || v === null || v === ''
+  })
+}

package/server/service/actuation/rule-loop.ts

@@ -0,0 +1,160 @@
+/*
+ * 규칙을 주기로 돌리는 타이머 하나.
+ *
+ * ── 왜 커널 틱이 아닌가 ──────────────────────────────────────────────────
+ * `tickGuarded` 는 예외가 나면 **그 트윈을 멈춘다.** 규칙 하나가 잘못됐다고 공장이 멈추면 안 된다.
+ * 그리고 굶김 감시가 느린 틱 셋에 트윈을 내리는데, 규칙은 DB 를 두 번 건드리므로 그 감시에 걸린다.
+ *
+ * ── 왜 이 간격인가 ───────────────────────────────────────────────────────
+ * 규칙이 보는 것은 **오래 이어진 조건**이다. 「병목이 세 시간째」를 1초마다 다시 물을 이유가 없다.
+ * 짧게 잡으면 얻는 것 없이 DB 를 두 번씩 더 친다.
+ *
+ * ── 겹쳐 돌지 않는다 ─────────────────────────────────────────────────────
+ * 한 바퀴가 간격보다 오래 걸리면 다음 발화가 겹친다. 겹치면 두 바퀴가 같은 근거 집합을 읽고 **같은
+ * 조치를 두 벌 낸다** — 중복을 막는 장치가 그 순간 통과된다.
+ */
+import { MES_COMMANDS } from '@operato/ops-contract'
+
+import { twinError, twinLog } from '../../engine/log.js'
+import { TwinEngine } from '../../engine/twin-engine.js'
+
+import { capabilitiesOf, getAdapter } from '../reference/reference-adapter.js'
+import { actuationReadinessOf, actuationTargetOf, routeActuation } from '../reference/actuation-routing.js'
+import { sweepPendingDispatch, type SweepReport } from './sweep-dispatch.js'
+import { catchUpEffects } from './catch-up-effects.js'
+import { databaseCommandStore } from './command-store.js'
+import { runRulesOnce } from './rule-runner.js'
+import { attentionsOf, modeOf, noteRun, rulesOf } from './rule-wiring.js'
+
+/** 몇 초마다 도나. 오래 이어진 조건을 보는 일이라 촘촘할 이유가 없다. */
+export const RULE_PERIOD_MS = 30_000
+
+let timer: any
+let running = false
+
+/** 주기를 세운다 — 두 번 불러도 하나만 선다. */
+export function startActuationRuleLoop(periodMs = RULE_PERIOD_MS): void {
+  if (timer) return
+
+  timer = setInterval(() => {
+    /* 앞 바퀴가 아직 돈다 — 겹치면 같은 조치를 두 벌 낸다. 건너뛰는 것이 맞다. */
+    if (running) return
+    running = true
+
+    tickRules()
+      .catch(err => twinError(`[twin-rule] 규칙 주기가 실패했다 — ${err?.message ?? err}`))
+      .finally(() => {
+        running = false
+      })
+  }, periodMs)
+
+  /* 이 타이머 때문에 프로세스가 안 죽지 않게. */
+  if (typeof timer?.unref === 'function') timer.unref()
+}
+
+export function stopActuationRuleLoop(): void {
+  if (!timer) return
+  clearInterval(timer)
+  timer = undefined
+}
+
+/**
+ * 일꾼이 한 바퀴에 무엇을 했나 — **바뀌었을 때만** 적는다.
+ *
+ * ── 왜 필요한가 (2026-09-04) ────────────────────────────────────────────────
+ * 처음에 보고를 받고 버렸다. 그러니 대기 줄에 조치가 앉아 있는데 아무 일도 안 일어날 때
+ * **이유를 알 길이 없었다** — 실제로 그 상태를 만나 30분을 뒤졌다. 집지 않는 것은 대개 옳은
+ * 판단이지만, 옳은 판단도 보이지 않으면 결함과 구별되지 않는다.
+ *
+ * ── 왜 바뀌었을 때만인가 ────────────────────────────────────────────────────
+ * 30초마다 같은 줄을 적으면 하루 2,880줄이고 그 사이의 진짜 변화가 묻힌다. 대기 줄의 모양이
+ * 그대로면 새로 말할 것이 없다 — `noteBlocked` 에서 지킨 것과 같은 규율이다.
+ */
+const lastSweep = new Map<string, string>()
+
+function noteSweep(domainId: string, report: SweepReport): void {
+  if (!report.seen) {
+    lastSweep.delete(domainId)
+    return
+  }
+
+  const skips = Object.entries(report.skipped)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([why, n]) => `${why} ${n}`)
+    .join(' · ')
+  const line = `${report.seen}건 대기 · 넘김 ${report.dispatched}${skips ? ` · ${skips}` : ''}`
+
+  if (lastSweep.get(domainId) === line) return
+  lastSweep.set(domainId, line)
+  twinLog(`[twin-sweep] ${line}`)
+}
+
+async function tickRules(): Promise<void> {
+  /*
+   * ── 유입 창을 먼저 굴린다 (2026-09-05) ─────────────────────────────────────
+   * 창이 닫히는 이유는 **시간이 지난 것**이다. 그런데 예전에는 「다음 사건이 왔을 때」와 「누가
+   * 물어볼 때」만 굴렀다 — 둘 다 안 올 수 있다.
+   *
+   * 그래서 사실이 드문 트윈은 표에 아무것도 안 남았다. 실측: 46건이 62분에 흩어져 온 트윈의 창이
+   * 1개, 사실 11건뿐인 트윈의 창이 48개 — **사실 수와 창 수가 거꾸로**였다. 창을 만든 것이 유입이
+   * 아니라 누가 물어본 것이었기 때문이다.
+   *
+   * **아무도 안 보는 트윈일수록 기록이 없었다.** 사실이 조용히 사라지는 것을 잡으려는 장부가 정확히
+   * 그 반대로 돌고 있었다(137봉투가 장부 없이 지나갔다 — 인티그레이션 레인 실측).
+   *
+   * 소유한 트윈이 없어도 굴린다 — 장부는 프로세스가 사는 동안 이어지고, 규칙을 돌 트윈이 없다는
+   * 것과 기록할 창이 없다는 것은 다른 사실이다.
+   */
+  const rolled = TwinEngine.rollAllIngestWindows()
+  if (rolled) twinLog(`[twin-ingest] 창 ${rolled}개를 닫아 적었다`)
+
+  const owned = TwinEngine.ownedTwins()
+  if (!owned.length) return
+
+  /*
+   * 트랜잭션을 넘기지 않는다 — 여러 트윈을 돌고, 한 트윈이 실패해도 앞의 트윈이 낸 것은 남아야 한다.
+   * 한 덩어리로 묶으면 마지막 트윈의 실패가 앞의 결과를 전부 물린다.
+   */
+  /*
+   * **놓친 보고를 함께 backfill 한다** — 관측 → 조치의 반대 방향이다.
+   *
+   * 같은 주기를 쓰는 이유는 값이다: 둘 다 몇 초마다 볼 일이고, 타이머를 둘 두면 내리고 세울 자리가
+   * 둘이 된다. 다만 **서로 막지 않는다** — 규칙이 터져도 backfill 은 돌아야 한다. 조치를 못 내는 것과
+   * 나간 조치의 결과를 모르는 것은 다른 사고다.
+   */
+  for (const domainId of new Set(owned.map(t => t.domainId))) {
+    await catchUpEffects(domainId, databaseCommandStore())
+    /*
+     * **넘길 차례를 기다리는 것들도 함께 줍는다** — 승인만 되고 안 나간 것, 실패해서 다시 해 볼 것.
+     *
+     * 정상 경로는 승인 직후에 이미 끝난다(§`dispatchAfterApproval`, 실측 282ms). 이 자리는 **그
+     * 사이에 프로세스가 죽은 경우**와 재시도만 본다. 그래서 30초로 충분하고 아무도 안 기다린다.
+     */
+    const swept = await sweepPendingDispatch(domainId, {
+      store: databaseCommandStore(),
+      actuate: command => routeActuation(domainId, command.instanceId, command),
+      idempotent: async instanceId => {
+        const target = await actuationTargetOf(domainId, instanceId).catch(() => undefined)
+        const type = (target as any)?.adapterType
+        return type ? capabilitiesOf(getAdapter(type)).includes('idempotent-actuation') : false
+      },
+      localReadiness: async instanceId => {
+        const r = await actuationReadinessOf(domainId, instanceId).catch(() => undefined)
+        /* 원격으로 물어 본 답은 쓰지 않는다 — 이 자리는 저쪽을 건드리지 않는 것이 규약이다. */
+        return r && (r as any).checked === 'local' ? (r as any) : undefined
+      }
+    })
+    noteSweep(domainId, swept)
+  }
+
+  await runRulesOnce({
+    ownedTwins: () => owned,
+    rulesOf,
+    attentionsOf,
+    modeOf,
+    store: databaseCommandStore(),
+    specs: MES_COMMANDS,
+    nowMs: () => Date.now(),
+    noteRun
+  })
+}