@things-factory/headless-twin 10.0.19 → 10.1.0

package/test/actuation-rule.test.ts

@@ -0,0 +1,266 @@
+/*
+ * **관측에서 조치를 낸다** — 그 판정.
+ *
+ * ── 무엇이 없었나 (2026-09-01) ───────────────────────────────────────────
+ * 승인 게이트를 세우고 나니 낼 수 있는 것이 **사람뿐**이었다. 계약은 낸 쪽을 네 가지로 두는데
+ * 사람 말고는 길이 없었다.
+ *
+ * ── 이 판정에서 무너지는 것 ──────────────────────────────────────────────
+ * 행복한 길은 짧다. 실제로 무너지는 것은 이것들이고, 넷 다 오류가 나지 않는다.
+ *
+ *   같은 조건이 매 주기 다시 올라온다   대기 줄에 같은 지시가 수십 개
+ *   방금 생긴 조건에 바로 올린다        깜빡인 것에 현장 지시가 나간다
+ *   한 번에 수백 개                     사람이 읽지 않고, 읽지 않으면 게이트는 시늉이다
+ *   값이 없는데 지시를 만든다           무엇을 지시하는지 모르는 것이 승인 대기에 선다
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { CMD, MES_COMMANDS, type CommandTypeSpec } from '@operato/ops-contract'
+
+import {
+  DEFAULT_COOLDOWN_MS,
+  DEFAULT_MAX_PER_RUN,
+  evaluateRules,
+  type ActuationRuleSpec,
+  type AttentionLike
+} from '../server/service/actuation/rule-evaluate.js'
+
+const SPECS: readonly CommandTypeSpec[] = MES_COMMANDS
+const ORDER = MES_COMMANDS[0]!
+const NOW = Date.parse('2026-09-01T03:00:00.000Z')
+const HOUR = 3_600_000
+
+/** 세 시간째 이어진 병목 하나. */
+const bottleneck = (over: Partial<AttentionLike> = {}): AttentionLike => ({
+  id: 'bottleneck:paint-1',
+  kind: 'bottleneck',
+  severity: 'high',
+  state: 'active',
+  anchor: { locationId: 'paint-1' },
+  timeStamp: new Date(NOW - 3 * HOUR).toISOString(),
+  params: { ratioPct: 118 },
+  ...over
+})
+
+/** 병목이 오래가면 생산 지시를 낸다 — 품목·단위는 규칙이 정하고 수량도 규칙이 정한다. */
+const rule = (over: Partial<ActuationRuleSpec> = {}): ActuationRuleSpec => ({
+  id: 'rule-1',
+  instanceId: 'twin-a',
+  attentionKind: 'bottleneck',
+  minSeverity: 'high',
+  minHeldMs: 2 * HOUR,
+  commandType: ORDER.type,
+  payloadTemplate: {
+    materialDefinitionId: 'urn:epc:idpat:sgtin:9521234.00001.*',
+    quantity: 20,
+    uom: 'EA',
+    note: '{locationId} 가 {ratioPct}% 로 {attentionKind} 다'
+  },
+  ...over
+})
+
+const run = (args: Partial<Parameters<typeof evaluateRules>[0]> = {}) =>
+  evaluateRules({
+    rules: [rule()],
+    attentions: [bottleneck()],
+    specs: SPECS,
+    openCauses: new Set<string>(),
+    nowMs: NOW,
+    ...args
+  })
+
+/* ── 낸다 ─────────────────────────────────────────────────────────────────── */
+
+test('★ 오래 이어진 조건이 조치로 올라간다 — 이 길이 없어 낼 수 있는 것이 사람뿐이었다', () => {
+  const out = run()
+
+  assert.equal(out.proposals.length, 1)
+  assert.equal(out.proposals[0]!.commandType, ORDER.type)
+  assert.equal(out.proposals[0]!.attentionId, 'bottleneck:paint-1')
+  assert.deepEqual(out.skips, [])
+})
+
+test('★ 주의의 값이 지시에 들어간다 — 승인하는 사람이 왜 올라왔는지 읽을 수 있게', () => {
+  const payload = run().proposals[0]!.payload
+  assert.equal(payload.note, 'paint-1 가 118% 로 bottleneck 다')
+  assert.equal(payload.quantity, 20)
+})
+
+test('★ 값 하나를 그대로 나르는 자리는 수로 남는다 — 수량이 문자열이면 그 뒤 계산이 무너진다', () => {
+  const out = run({
+    rules: [rule({ payloadTemplate: { ...rule().payloadTemplate, quantity: '{ratioPct}' } })]
+  })
+  assert.strictEqual(out.proposals[0]!.payload.quantity, 118, '문자열 "118" 이 되었다')
+})
+
+/* ── 같은 조건을 두 번 올리지 않는다 ─────────────────────────────────────── */
+
+test('★ 이미 올라가 있는 근거에는 다시 올리지 않는다 — 주기마다 같은 지시가 쌓이지 않게', () => {
+  const out = run({ openCauses: new Set(['bottleneck:paint-1']) })
+  assert.equal(out.proposals.length, 0)
+  assert.deepEqual(out.skips, [], '중복은 이유를 말할 것이 아니다 — 정상이다')
+})
+
+test('★ 한 주의에 규칙이 둘 붙어도 조치는 하나다 — 같은 조건에 두 지시가 나가면 현장이 두 번 움직인다', () => {
+  const out = run({ rules: [rule({ id: 'rule-1' }), rule({ id: 'rule-2' })] })
+  assert.equal(out.proposals.length, 1)
+})
+
+test('★ 근거가 저장소에서 온다 — 프로세스 기억에 두면 재기동이 곧 중복이다', () => {
+  /*
+   * 판정이 순수 함수라 「이미 올라간 것」을 인자로 받는다. 재기동한 프로세스도 저장소에서 같은 집합을
+   * 읽어 넘기면 같은 답이 나온다.
+   */
+  const openCauses = new Set(['bottleneck:paint-1'])
+  assert.equal(run({ openCauses }).proposals.length, 0)
+  assert.equal(run({ openCauses: new Set() }).proposals.length, 1, '집합이 비면 다시 올라간다 — 그것이 저장소의 몫이다')
+})
+
+/* ── 깜빡이는 것에 지시를 내지 않는다 ───────────────────────────────────── */
+
+test('★ 아직 짧게 이어진 조건은 올리지 않는다', () => {
+  const out = run({ attentions: [bottleneck({ timeStamp: new Date(NOW - 10_000).toISOString() })] })
+  assert.equal(out.proposals.length, 0)
+})
+
+test('★ 언제부터인지 모르는 주의는 올리지 않고 말한다 — 모름을 「오래됐다」로 읽지 않는다', () => {
+  const out = run({ attentions: [bottleneck({ timeStamp: undefined })] })
+  assert.equal(out.proposals.length, 0)
+  assert.equal(out.skips.length, 1)
+  assert.match(out.skips[0]!.reason, /언제부터인지 말하지 않는다/)
+})
+
+test('모양이 아닌 시각도 모름으로 본다 — 지어낸 기간으로 지시를 내지 않는다', () => {
+  const out = run({ attentions: [bottleneck({ timeStamp: '어제' })] })
+  assert.equal(out.proposals.length, 0)
+  assert.match(out.skips[0]!.reason, /언제부터인지 말하지 않는다/)
+})
+
+test('기간을 요구하지 않는 규칙은 처음 본 주기에 올린다', () => {
+  const out = run({
+    rules: [rule({ minHeldMs: undefined })],
+    attentions: [bottleneck({ timeStamp: new Date(NOW - 1000).toISOString() })]
+  })
+  assert.equal(out.proposals.length, 1)
+})
+
+/* ── 낸 지 얼마 안 된 근거에는 다시 내지 않는다 ─────────────────────────── */
+
+test('★ 승인해도 곧바로 다시 내지 않는다 — 걸어 보고 실제로 만든 상태다', () => {
+  /*
+   * 결정을 기다리는 것만 보고 중복을 막았더니, **승인하는 순간** 그 커맨드가 대기에서 빠지고 조건은
+   * 그대로 서 있어 다음 바퀴가 같은 것을 또 냈다. 사람이 승인할수록 대기 줄이 다시 차는 모양이었다.
+   */
+  const justProposed = new Map([['bottleneck:paint-1', NOW - 60_000]])
+  const out = run({ openCauses: new Set(), lastProposedAt: justProposed })
+  assert.equal(out.proposals.length, 0)
+})
+
+test('★ 기다리는 시간이 지나면 다시 낸다 — 조건이 여전하면 다시 판단거리다', () => {
+  const longAgo = new Map([['bottleneck:paint-1', NOW - 2 * HOUR]])
+  const out = run({ openCauses: new Set(), lastProposedAt: longAgo })
+  assert.equal(out.proposals.length, 1)
+})
+
+test('★ 선언하지 않아도 기다린다 — 그 결함을 기본값으로 두지 않는다', () => {
+  const recent = new Map([['bottleneck:paint-1', NOW - (DEFAULT_COOLDOWN_MS - 1000)]])
+  const out = run({ rules: [rule({ cooldownMs: undefined })], openCauses: new Set(), lastProposedAt: recent })
+  assert.equal(out.proposals.length, 0)
+})
+
+test('0 으로 두면 기다리지 않는다 — 그 뜻을 그대로 존중한다', () => {
+  const justProposed = new Map([['bottleneck:paint-1', NOW - 1000]])
+  const out = run({ rules: [rule({ cooldownMs: 0 })], openCauses: new Set(), lastProposedAt: justProposed })
+  assert.equal(out.proposals.length, 1)
+})
+
+test('낸 적 없는 근거는 기다리지 않는다', () => {
+  const other = new Map([['bottleneck:other', NOW - 1000]])
+  assert.equal(run({ lastProposedAt: other }).proposals.length, 1)
+})
+
+/* ── 무엇을 걸러내나 ─────────────────────────────────────────────────────── */
+
+test('★ 확인한 주의에는 올리지 않는다 — 사람이 이미 본 것이다', () => {
+  assert.equal(run({ attentions: [bottleneck({ state: 'acknowledged' })] }).proposals.length, 0)
+  assert.equal(run({ attentions: [bottleneck({ state: 'cleared' })] }).proposals.length, 0)
+})
+
+test('심각도가 문턱 아래면 올리지 않는다', () => {
+  assert.equal(run({ attentions: [bottleneck({ severity: 'medium' })] }).proposals.length, 0)
+  assert.equal(run({ attentions: [bottleneck({ severity: 'critical' })] }).proposals.length, 1)
+})
+
+test('★ 모르는 심각도는 통과시키지 않는다 — 모름을 「충분하다」로 읽지 않는다', () => {
+  assert.equal(run({ attentions: [bottleneck({ severity: 'ㅁ' })] }).proposals.length, 0)
+})
+
+test('꺼 둔 규칙은 판정하지 않는다 — 지우지 않고 끌 수 있어야 한다', () => {
+  assert.equal(run({ rules: [rule({ enabled: false })] }).proposals.length, 0)
+})
+
+test('다른 종류의 주의는 이 규칙이 보지 않는다', () => {
+  assert.equal(run({ attentions: [bottleneck({ kind: 'scrap-high' })] }).proposals.length, 0)
+})
+
+/* ── 지어낸 값으로 지시를 만들지 않는다 ─────────────────────────────────── */
+
+test('★ 바꿔 넣을 값이 주의에 없으면 올리지 않고 말한다', () => {
+  const out = run({
+    rules: [rule({ payloadTemplate: { ...rule().payloadTemplate, quantity: '{shortfall}' } })]
+  })
+  assert.equal(out.proposals.length, 0)
+  assert.equal(out.skips.length, 1)
+  assert.match(out.skips[0]!.reason, /넣을 값이 주의에 없다/)
+  assert.match(out.skips[0]!.reason, /shortfall/)
+})
+
+test('★ 요구하는 칸이 비면 올리지 않고 말한다 — 무엇을 지시하는지 모르면 승인할 근거가 없다', () => {
+  const out = run({ rules: [rule({ payloadTemplate: { note: '병목' } })] })
+  assert.equal(out.proposals.length, 0)
+  assert.match(out.skips[0]!.reason, /요구하는 칸이 비었다/)
+  for (const key of ORDER.required) assert.match(out.skips[0]!.reason, new RegExp(key))
+})
+
+test('★ 선언되지 않은 조치 종류를 가리키는 규칙은 말한다 — 조용히 아무 일도 안 하지 않는다', () => {
+  const out = run({ rules: [rule({ commandType: 'line.shutdown' })] })
+  assert.equal(out.proposals.length, 0)
+  assert.equal(out.skips.length, 1)
+  assert.match(out.skips[0]!.reason, /선언되지 않은 조치 종류/)
+})
+
+test('★ 커널 자극을 가리키는 규칙도 같은 자리에서 걸린다 — 모델 자극이 현장 지시가 되지 않게', () => {
+  /*
+   * `Attention.suggestedAction.command` 가 나르는 것이 이 어휘다. 주의를 읽어 규칙을 쓰다 보면 그 값이
+   * 손에 잡힌다 — `resource.repair` 는 「모델에서 수리된 것으로 두라」이고 「사람을 보내라」가 아니다.
+   */
+  const out = run({ rules: [rule({ commandType: CMD.resourceRepair })] })
+  assert.equal(out.proposals.length, 0)
+  assert.match(out.skips[0]!.reason, /선언되지 않은 조치 종류/)
+})
+
+/* ── 한 번에 쏟지 않는다 ─────────────────────────────────────────────────── */
+
+test('★ 상한에 닿으면 두고 오고, 두고 온 수를 말한다 — 조용히 자르면 다 올린 줄로 읽는다', () => {
+  const many = Array.from({ length: 30 }, (_, i) =>
+    bottleneck({ id: `bottleneck:line-${i}`, anchor: { locationId: `line-${i}` } })
+  )
+  const out = run({ attentions: many, maxPerRun: 5 })
+
+  assert.equal(out.proposals.length, 5)
+  assert.equal(out.withheld, 25)
+})
+
+test('상한은 기본값이 있다 — 사람이 읽을 수 있는 수', () => {
+  const many = Array.from({ length: DEFAULT_MAX_PER_RUN + 3 }, (_, i) =>
+    bottleneck({ id: `bottleneck:line-${i}`, anchor: { locationId: `line-${i}` } })
+  )
+  const out = run({ attentions: many })
+  assert.equal(out.proposals.length, DEFAULT_MAX_PER_RUN)
+  assert.equal(out.withheld, 3)
+})
+
+test('두고 온 것이 없으면 그 자리를 만들지 않는다 — 0 을 「잘렸다」로 읽히게 하지 않는다', () => {
+  assert.equal(run().withheld, undefined)
+})

package/test/actuation-seam.test.ts

@@ -0,0 +1,249 @@
+/*
+ * ★ **커넥터가 적은 선언이 게이트의 답으로 이어지는가** — 오늘 결함이 정확히 이 사이에서 났다.
+ *
+ * ── 무엇이 났나 (2026-09-02) ────────────────────────────────────────────────
+ * 시험은 두 쪽에 다 있었다. 등록 검사를 걷는 것(§`connector-capability-declaration.test.ts`)과
+ * 게이트 판정을 걷는 것(§`actuation-target.test.ts`). 그런데 **그 둘을 잇는 것이 없었다.**
+ *
+ *   MES 커넥터가 actuate 를 다 만들었다
+ *   능력 축에 'actuate' 라는 이름이 없었다        ← 여기가 비어 있었다
+ *   커넥터는 ['live','control'] 만 적을 수 있었다
+ *   넘기는 자리는 「구현이 없습니다」로 답했다
+ *
+ * 양쪽 시험은 각자 초록이었다. 이어 걷는 시험이 있었으면 그 자리에서 걸렸다.
+ *
+ * 그래서 이 파일은 **레지스트리에서 값을 꺼내** 게이트에 넣는다. 손으로 적은 값을 넣으면 오늘 났던
+ * 어긋남을 그대로 지나친다 — 그 어긋남이 레지스트리와 게이트 사이에 있었기 때문이다.
+ */
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+
+/* 등록 검사가 경고로 말한다 — 그 말도 이 자리에서 함께 본다. */
+const warnings: string[] = []
+const originalWarn = console.warn
+console.warn = (...args: unknown[]) => {
+  warnings.push(args.join(' '))
+}
+process.on('exit', () => (console.warn = originalWarn))
+
+const { registerAdapterType, getAdapter, capabilitiesOf } = await import(
+  '../server/service/reference/reference-adapter.js'
+)
+type ActuationReadiness = import('../server/service/reference/reference-adapter.js').ActuationReadiness
+const { actuationTarget, isActuationAllowed } = await import('../server/service/reference/actuation-target.js')
+
+let seq = 0
+function register(over: Record<string, unknown>) {
+  const type = `seam-${++seq}`
+  registerAdapterType({
+    type,
+    async fetchMaster() {
+      return {} as any
+    },
+    ...over
+  } as any)
+  return type
+}
+
+/**
+ * 등록된 커넥터의 **실제 값**으로 게이트에 묻는다 — 배선(§`actuation-routing.ts`)이 하는 것과 같다.
+ *
+ * 저장소만 여기서 대신한다. 트윈과 원본은 있는 것으로 두고, 갈리는 것은 커넥터가 무엇을 적었나다.
+ */
+function askGate(adapterType: string, siteId?: string) {
+  /*
+   * **기본값을 두지 않는다.** 처음에 `siteId = 'plant-a'` 로 두었더니 `askGate(type, undefined)` 가
+   * 기본값을 집어서 「사이트를 모르는 경우」를 시험할 수 없었다 — 시험이 초록인데 아무것도 확인하지
+   * 않는 상태였다. 부르는 쪽이 매번 적는다.
+   */
+  const adapter = getAdapter(adapterType)
+  return actuationTarget({
+    instanceId: 'twin-a',
+    twinExists: true,
+    siteId,
+    ref: { source: 'twin-a', adapterType },
+    adapterRegistered: !!adapter,
+    capabilities: capabilitiesOf(adapter),
+    declaresActuate: !!adapter?.capabilities?.includes('actuate'),
+    hasActuateImpl: typeof adapter?.actuate === 'function'
+  })
+}
+
+/* ── 선언과 구현이 다 있으면 게이트가 열린다 ────────────────────────────────── */
+
+test('★ 커넥터가 조치를 적고 만들었으면 게이트가 열린다 — 이 한 줄이 없어서 하루가 갔다', () => {
+  const before = warnings.length
+  const type = register({ capabilities: ['live', 'actuate'], openLiveFeed: () => () => {}, actuate: async () => ({ ok: true }) })
+
+  assert.equal(warnings.length, before, '맞게 적었는데 등록이 무슨 말을 했다')
+
+  const target = askGate(type, 'plant-a')
+  assert.equal(isActuationAllowed(target), true, '커넥터는 조치를 낼 수 있는데 게이트가 막았다')
+  assert.deepEqual(target, { ok: true, siteId: 'plant-a', adapterType: type, source: 'twin-a' })
+})
+
+/* ── 오늘 났던 상태를 그대로 세운다 ─────────────────────────────────────────── */
+
+test('★ 구현만 있고 선언이 없으면 — 등록이 말하고, 게이트도 같은 것을 말한다', () => {
+  /*
+   * 이것이 오늘의 상태다. 두 자리가 **같은 원인을 같은 말로** 짚어야 한다. 등록 경고는 뜰 때 한 번
+   * 지나가고 아무도 안 볼 수 있다. 넘기려는 사람이 보는 것은 게이트의 답이다.
+   */
+  const before = warnings.length
+  const type = register({ capabilities: ['live'], openLiveFeed: () => () => {}, actuate: async () => ({ ok: true }) })
+
+  const said = warnings.slice(before).join('\n')
+  assert.ok(said.includes('actuate'), '등록이 조치 선언이 빠진 것을 말하지 않았다')
+
+  const target = askGate(type, 'plant-a') as any
+  assert.equal(target.code, 'not-declared')
+  assert.match(target.detail, /capabilities/, '게이트가 무엇을 넣어야 하는지 말하지 않았다')
+})
+
+test('★ 선언만 있고 구현이 없으면 — 등록은 조용하고, 게이트만 말한다', () => {
+  /*
+   * 등록 검사는 이 방향을 보지 않는다(구현했는데 선언 안 한 쪽만 본다). 그래서 **게이트가 말하지
+   * 않으면 아무도 말하지 않는다.** 그 사람은 조치를 하겠다고 적어 두었으니 「관측만 냅니다」는
+   * 사실이 아니다.
+   */
+  const before = warnings.length
+  const type = register({ capabilities: ['live', 'actuate'], openLiveFeed: () => () => {} })
+
+  assert.equal(warnings.length, before, '등록이 이 방향을 말한다면 게이트의 문장도 다시 봐야 한다')
+  assert.deepEqual(capabilitiesOf(getAdapter(type)), ['live'], '능력 판정이 구현 없는 선언을 걸러 내지 않았다')
+
+  const target = askGate(type, 'plant-a') as any
+  assert.equal(target.code, 'not-implemented')
+  assert.doesNotMatch(target.detail, /관측만/)
+})
+
+test('선언도 구현도 없으면 이 커넥터는 조치를 받지 않는다', () => {
+  const type = register({ capabilities: ['live'], openLiveFeed: () => () => {} })
+
+  const target = askGate(type, 'plant-a') as any
+  assert.equal(target.code, 'not-supported')
+  assert.match(target.detail, /관측만/)
+})
+
+/* ── 게이트가 여는 것은 능력 판정을 지난 것뿐이다 ──────────────────────────── */
+
+test('★ 등록된 커넥터마다 게이트의 답이 능력 판정과 어긋나지 않는다', () => {
+  /*
+   * 이것이 이 파일의 요점이다. 「능력에 actuate 가 있다」와 「게이트가 열린다」가 **항상 같이** 가야
+   * 한다. 오늘은 둘이 갈렸다 — 능력 축에 그 이름이 없어서 앞엣것이 영원히 거짓이었고, 게이트는
+   * 그것과 무관하게 무조건 닫혀 있었다.
+   */
+  const cases = [
+    { capabilities: ['live', 'actuate'], openLiveFeed: () => () => {}, actuate: async () => ({ ok: true }) },
+    { capabilities: ['live'], openLiveFeed: () => () => {}, actuate: async () => ({ ok: true }) },
+    { capabilities: ['live', 'actuate'], openLiveFeed: () => () => {} },
+    { capabilities: ['actuate'], actuate: async () => ({ ok: true }) },
+    { capabilities: ['live'], openLiveFeed: () => () => {} },
+    {}
+  ]
+
+  for (const spec of cases) {
+    const type = register(spec)
+    const canActuate = capabilitiesOf(getAdapter(type)).includes('actuate')
+    const opened = isActuationAllowed(askGate(type, 'plant-a'))
+
+    assert.equal(
+      opened,
+      canActuate,
+      `능력 판정은 ${canActuate} 인데 게이트는 ${opened} 로 답했다 (${JSON.stringify(Object.keys(spec))})`
+    )
+  }
+})
+
+/* ── 사이트를 모르면 능력과 무관하게 닫힌다 ────────────────────────────────── */
+
+test('★ 조치를 낼 수 있는 커넥터라도 사이트를 모르면 닫힌다 — 잘못된 공장이 만든다', () => {
+  const type = register({ capabilities: ['actuate'], actuate: async () => ({ ok: true }) })
+
+  assert.equal(isActuationAllowed(askGate(type, 'plant-a')), true)
+  assert.equal((askGate(type, undefined) as any).code, 'no-site')
+  assert.equal((askGate(type, '   ') as any).code, 'no-site')
+})
+
+test('등록되지 않은 커넥터를 가리키면 능력을 묻기 전에 닫힌다', () => {
+  const target = askGate('seam-없는-커넥터', 'plant-a') as any
+
+  assert.equal(target.code, 'no-adapter')
+  assert.match(target.detail, /seam-없는-커넥터/, '어느 커넥터인지 말하지 않으면 찾을 수 없다')
+})
+
+/* ── 저쪽이 받을 준비가 됐나 ────────────────────────────────────────────────── */
+
+test('★ 확인할 길이 없으면 「준비됐다」로 답하지 않는다 — 없는 확인을 통과로 읽지 않게', async () => {
+  /*
+   * 실측(2026-09-03): 승인된 조치를 넘겼더니 저쪽이 503 을 답했다 — 저쪽 프로세스에 비밀값이 실려
+   * 있지 않았다. 우리 쪽 설정·주소·서명은 다 맞았다. 보내 보기 전에는 알 수 없어서 사람이 승인
+   * 화면까지 가서 누르고, 실패를 보고, 다시 로그인했다.
+   *
+   * 그래서 커넥터에 「받을 준비가 됐나」를 묻는 얼굴을 뒀다. 안 만든 커넥터에 대해 이 자리가
+   * 「준비됐다」로 답하면, 얼굴이 있으나 없으나 같아진다.
+   */
+  const type = register({ capabilities: ['actuate'], actuate: async () => ({ ok: true }) })
+  const adapter = getAdapter(type)
+
+  assert.equal(typeof adapter?.actuationReadiness, 'undefined', '이 커넥터는 그 얼굴을 만들지 않았다')
+
+  /* 판정만 걷는다 — 배선은 저장소를 지나므로 여기서 세우지 않는다(§ 이 파일의 머리말). */
+  const answer = notCheckable(type)
+  assert.equal(answer.ready, undefined, '모름을 참·거짓으로 답했다')
+  assert.equal(answer.code, 'not-checkable')
+})
+
+test('★ 「모른다」와 「안 된다」가 다른 값이다', () => {
+  const unknown = notCheckable('some-connector')
+  const refused: ActuationReadiness = { checked: 'local', ready: false, reason: '주소가 없습니다', code: 'no-endpoint' }
+
+  assert.equal(unknown.ready, undefined)
+  assert.equal(refused.ready, false)
+  assert.notEqual(unknown.code, refused.code)
+})
+
+test('어디까지 봤는지 함께 답한다 — 「살아 있다고 말한 적 없다」와 「죽었다」는 다르다', () => {
+  assert.equal(notCheckable('x').checked, 'local')
+})
+
+/**
+ * 배선이 커넥터에 얼굴이 없을 때 만드는 답 — 그 모양을 여기서 못 박는다.
+ *
+ * 저장소를 지나는 함수(§`actuationReadinessOf`)를 부르면 시험이 TypeORM 을 세워야 한다. 그 답의
+ * **모양**이 계약이고, 모양이 바뀌면 화면이 조용히 다르게 읽는다.
+ */
+function notCheckable(adapterType: string): ActuationReadiness {
+  return {
+    checked: 'local',
+    reason: `커넥터 "${adapterType}" 는 저쪽이 받을 준비가 됐는지 알려 주지 않습니다 — 넘겨 보고 알게 됩니다`,
+    code: 'not-checkable'
+  }
+}
+
+/* ── 화면이 부를 자리가 있는가 ─────────────────────────────────────────────── */
+
+test('★ 판정 함수를 부르는 자리가 있다 — 없으면 화면이 물을 방법이 없다', () => {
+  /*
+   * 판정을 만들어 두고 **부르는 자리를 안 만들었다.** 인티그레이션 레인이 두 번 짚어 줬다 —
+   * `actuationTargetOf` 도, 오늘 만든 `actuationReadinessOf` 도 부르는 곳이 없었다.
+   *
+   * 그래서 못 넘기는 조치도 눌러 보고 알게 됐고, 저쪽에 비밀값이 없던 날 승인 하나가 헛돌았다.
+   * 이 시험은 그 자리가 스키마에 서 있는지 본다 — 문자열로 세는 것이 약하지만, 없어지는 것을
+   * 잡는 데는 충분하다(리졸버를 세우려면 type-graphql 스키마를 지어야 한다).
+   */
+  const source = readFileSync(
+    new URL('../server/service/actuation/twin-command-resolver.ts', import.meta.url).pathname,
+    'utf-8'
+  )
+
+  assert.match(source, /twinActuationReadiness/, '화면이 부를 조회가 없다')
+  assert.match(source, /actuationTargetOf/, '대상 판정을 부르지 않는다')
+  assert.match(source, /actuationReadinessOf/, '준비 판정을 부르지 않는다')
+
+  /* 조회여야 한다 — 이 답으로 넘김을 막지 않으므로 뮤테이션이 아니다. */
+  const at = source.indexOf('twinActuationReadiness')
+  const before = source.slice(Math.max(0, at - 400), at)
+  assert.match(before, /@Query/, '알림인데 뮤테이션으로 두었다')
+})